Managing a big project with multiple squads working on the same code base can be very challenging. If you are a developer, you should hear of Continuous Integration / Continuous Delivery (CI/CD). Far from merely automating tedious tasks, it serves as the linchpin in enhancing team collaboration, streamlining workflows, and fortifying product quality.
So today, I want to share some experiences that will help you set up a comprehensive CI/CD pipeline to streamline the development process and ensure a more cohesive and efficient workflow in the projects with developers working in specialized full-stack squads.
Challenges and Solutions
1. Following Coding Guidelines and Naming Conventions
Challenge: Each developer may have their preferred coding style and approach in a team. Discrepancies in style and naming conventions can lead to confusion, increase the complexity of the codebase, and make maintenance more cumbersome.
Solution with CI/CD: Implementing a CI/CD pipeline allows the team to enforce coding standards through automated linting and formatting checks. Tools like SwiftLint for Swift and Ktlint for Kotlin can be integrated into the pipeline to analyze code for stylistic errors and deviations from agreed-upon guidelines. The process ensures uniformity across the codebase and reduces the time spent in manual code reviews.
2. Identifying and Resolving Logical Errors
Challenge: Logic errors can be elusive, especially in a complex codebase where multiple developers contribute. These errors might not be caught until later stages, making them more expensive and time-consuming to fix.
Solution with CI/CD: Automated unit tests, integration tests, and end-to-end tests with CI/CD ensure that logic errors are detected early in the development process. By running these tests continuously, developers can identify and rectify mistakes promptly, thereby maintaining the code quality.
3. Understanding Colleagues’ Contributions
Challenge: With many developers working on different parts of the project, understanding what others are working on and how it integrates with your work becomes a complex task. This lack of understanding can lead to duplication of effort, conflicts, and inefficient collaboration.
Solution with CI/CD: Pull Requests (PRs) are more than a tool for merging code; they foster collaboration, enhance knowledge sharing, and maintain quality control. Here’s how to ensure your team always creates effective Pull Requests:
Provide Details on Changes: Outline what was changed, why, and how it was changed to offer comprehensive insights to reviewers.
Keep PRs Small: Limiting the PR size (e.g., under 50 changes) ensures that reviews are manageable and efficient.
Use Self-Explanatory Titles: Clear, descriptive titles offer immediate context and guide the review process smoothly.
And with CI/CD, you can set up some rules to ensure everyone sticks to these guidelines when submitting for a review. Here are some excellent tools to help you out:
Danger is a powerful tool that helps automate everyday code review process chores. It’ll remind you of common mistakes like too big PR or missing PR’s description.
Pull Request Ticket Check Action is a Github Action that ensures every pull request has a ticket ID in the title, keeping everything organized.
4. Streamlining the QA Build Release Process
Challenge: Releasing a build for QA testing is a critical but often cumbersome step in the development process. You must manually create the build, upload it to distribution services like TestFlight, Google Play Console, or Firebase Distribution, and then coordinate with testers to begin the QA process. These manual steps not only interrupt the coding flow but also pose error risks due to differing build environments. This disruption detracts from the essential coding activities and causes delays in the broader development cycle.
Solution with CI/CD: Implementing a CI/CD deployment pipeline provides an adept solution to these challenges. By automating the process, developers can focus on their primary responsibilities without being sidetracked by the logistical detail of the QA build release.
Automated Build Creation: Utilizing a tool like Fastlane, the CI/CD can be configured to automatically compile and package the build whenever you want.
Efficient Distribution to Testers: Through the CI/CD pipeline, the distribution of builds to various testing platforms is handled precisely, ensuring the correct version reaches the intended recipients without requiring manual oversight.
Seamless Communication with Testers: The process is further refined by CI/CD through timely notifications to testers when a new build is ready. Following a consistent commit message convention, such as Conventional Commit, even allows the generation of changelogs from commit history, offering testers additional context on what’s included in the build. This ensures that testers are kept in the loop and can begin work without delays.
5. Coordinating Release Builds Across Teams
Challenge: At the end of each sprint, a collaborative effort is needed to craft the final release build. This involves gathering all corresponding tickets or issues for the Release Candidate (RC) build, conducting tests, and ultimately publishing to the App Store. This process mirrors the QA release approach but is often more hands-on. The necessity for exacting attention to detail and seamless cross-team coordination amplifies the complexity of ensuring the delivery’s quality.
Solution with CI/CD: By leveraging CI/CD, the coordination of release builds across teams can be significantly streamlined. Many steps from the QA build release pipeline can be repurposed here, thus substantially reducing time spent on manual tasks and diminishing the likelihood of human error. Tasks such as compiling the build, uploading to the App Store or Play Store, and communicating about the RC build can all be automated.
An added advantage of this streamlined process is the ability to collate ticket numbers — and their respective links — for inclusion in the changelog. This serves a dual purpose: testers have a clear assessment roadmap, and the company gets a comprehensive release overview. When sending out a release announcement, having a detailed changelog not only enhances transparency but also fosters a sense of collective accomplishment across the company.
Establishing an efficient CI/CD pipeline involves more than just integrating tools and automation. It requires a culture of clear communication and collaboration within the team. Every aspect, from coding conventions to Pull Request templates, needs mutual agreements. Even the release process requires teamwork and shared understanding.
These decisions may initially seem daunting, like puzzle pieces scattered across the table, each demanding meticulous consideration and placement. Once they are in place and pipelines are implemented, pain points associated with code reviews, QA, and release processes will dissipate, giving your team room to focus on crafting excellent features.