As developers, we are quite comfortable working within our internal teams,where strong relationships have been built over time. However, one key aspect we often overlook is the critical skills required to collaborate with an entirely new team, especially when facing tight deadlines. While each project and team may present unique challenges, let’s focus on some key points below rather than personal experiences.
Key considerations before starting to code:
- Onboarding to External Domain: Familiarize yourself with communication channels, external company policies (such as leave and calendars), work schedules, new email addresses, and any software updates required for ongoing or legacy projects.
- Access and Permissions: Ensure you have the necessary platform permissions and credentials. Identify where key documentation is stored to properly document your work as needed.
- Team Skills and Roles: Understand the skill sets and roles of team members (backend, frontend, etc.) to gauge project velocity and distribute tasks effectively.
- Design Alignment: Make sure that all designs are finalized, fully aligned, and signed off before development begins to avoid unnecessary revisions.
- Infrastructure: Have a clear understanding of the project’s infrastructure requirements and how it will be set up or maintained.
- Go-To Person (Tech Lead): Identify the Tech Lead for technical guidance and decision-making to ensure alignment with the project’s objectives.
- Scrum Master and Story Points: Clarify the involvement of the Scrum Master, story point allocation, and the sprint infrastructure to manage project progress.
- Time Logging: As an external team member, ensure you log your time accurately for internal record-keeping and billing purposes.
- Project Goal: Clearly understand the project scope and objectives to determine what the project entails and establish the ultimate goal. This comprehension will inform decision-making, prioritize tasks, and ensure alignment among team members throughout the project’s lifecycle.
By addressing these key points, you’ll be better prepared for a smooth and efficient start to coding.
Effective Practices for Planning Sessions:
- Team Collaboration and Culture Building: Hold regular team sessions to foster a positive team culture and gain an understanding of each team member’s skills and strengths.
- 1-on-1s with Tech Leads: Tech leads should have regular one-on-one meetings with developers to address any concerns or potential blockers that could impact project deadlines.
- Code Standards Meetings: Organize mandatory team meetings focused on coding topics. Create a comprehensive checklist covering backend and frontend frameworks, code structure, naming conventions, and coding standards. Discuss external plugins or modules that could simplify development.
- Project Infrastructure Setup: Schedule dedicated sessions to set up the project’s infrastructure to ensure everything is properly aligned from the start.
- Card Spec and Refinement Sessions: Involve designers in card spec sessions and refinements to clarify any questions early on, ensuring that the team has a shared understanding of the tasks at hand.
- Minimizing Future Refactoring: These planning sessions will help reduce the need for extensive refactoring later, which can lead to coding conflicts, especially in large teams.
By adopting these practices, you can improve team alignment, streamline development, and prevent potential issues during the project lifecycle.
Starting the work, here are the key things to have from the get-go:
- Repo and Pipeline Setup: Set up the repository and any CI/CD pipelines that the team will need. This ensures smooth integration and deployment processes from the beginning.
- Directory Structure: Set up the main directories and structure early. As the project progresses, code reviews can help refine naming conventions and layouts that don’t make sense.
- Linting, Prettier, and Testing Setup: Implement linting, Prettier, and testing frameworks with examples right away. Since every developer may have their own coding style, this will enforce consistency. Add pre-commit hooks like Husky to run linting and pipelines locally to maintain code quality.
- Plugins and Connections: Install all necessary plugins for the project, such as clients for API calls and connection settings, so the team can start working without delays.
- Demo Page for Shared Components (frontend): Set up a demo page where common/shared components are displayed in various states. This helps avoid development bottlenecks when building full pages, as teams will know upfront which components are ready or still needed. It also allows QAs and designers to sign off on components early on.
- Theming and Color Tokens (frontend): Establish the basic theme and color tokens from the start, providing a foundation for consistent design across the project.
- Domain Setup: Establish the domain architecture, including configuring servers, databases, and networking elements. Ensure that the domain is properly structured to support the application’s functionality and performance requirements.
- Shared Databases: Set up a shared database, like a staging environment, where QA can test their work and where demos can be run.
- Ticket Prioritization: Organize the tickets in a logical flow. For example, start with the login, user roles, and homepage infrastructure so that features can be built on top of them without roadblocks.
- API Documentation: Document all backend collections, APIs, and endpoints early on to ensure everyone on the team has easy access to the information they need.
- Code Review Strategy: Set up a review strategy where at least two senior developers must approve PRs. Rotate reviewers to ensure everyone gets familiar with the codebase and different parts of the project.
By setting these up from the beginning, the team will have a solid foundation to work from, reducing confusion and ensuring smoother development.
Team Dynamics
- Balancing Meetings and Development: Time is critical, so it’s important to strike a balance between productive meetings and actual development work. Meetings should be purposeful and limited to what’s necessary.
- Shared Responsibility for Perspectives: While everyone is encouraged to share their perspective, we recognize that not all discussions will reach a consensus. The key is to ensure every voice is heard, but maintain focus on the end goal of the meeting.
- Laser-Focused Meetings: Meetings should be tightly focused on objectives. If conversations stray off-topic, it’s everyone’s responsibility to gently redirect them back on track to ensure time is used efficiently.
- Dedicated Tech Channel: Set up a tech channel where developers can leave messages regarding issues, concerns, or assistance needed. This promotes quick problem-solving and keeps the team connected.
- Reinforce Team Care: Operate under the assumption that every team member cares about the success of others. Reinforce this positive feeling within the team by actively supporting and encouraging each other.
- Constructive Feedback: Part of being a good teammate is offering prompt, efficient, and constructive feedback. Even if it’s uncomfortable, giving feedback is a form of kindness, as it helps each member grow and improve their work.
- Mistakes Are Okay: Everyone is allowed to make mistakes. What’s important is learning from them and using the experience to grow as a team.
- Keep Time Promises: Stick to your estimated time for completing tasks. If you foresee any delays, raise the issue as soon as possible to manage expectations.
- Over-Communicate: It’s better to over-communicate than under-communicate. Add any changes, updates, or outcomes as comments to the relevant ticket, ensuring everyone is informed and prepared for when team members are unavailable.
- Service Communication: Always maintain clear and effective communication between internal and external teams when providing a service. Ensure that all requirements outlined in the contract are met, and take proactive steps to avoid any scope creep that could extend beyond the agreed-upon project terms.
By fostering open communication, constructive feedback, and a supportive environment, the team can work efficiently while maintaining a strong sense of collaboration and care for one another.
Conclusion
In summary, effective collaboration with external teams relies on thorough preparation, clear communication, and a supportive team culture. By setting up infrastructure early, aligning on standards, and fostering constructive feedback, teams can avoid common issues and work smoothly toward shared goals. Balancing productive meetings with focused development time and encouraging open communication help maintain momentum, enabling teams to deliver quality results within tight deadlines.
Kurt Wasserfall
Mobile Development Lead