October 12, 2023

Software: Code shipping cycle

Software deployment is a multi-faceted process that goes well beyond writing code. It involves meticulous planning, development, testing, and eventual release to ensure software quality and reliability. Any product manager should understand challenges and processes behind the scene. As you know, creating software is not just about creating it in lab conditions, but also needed infrastructure to make sure it will work in different environments and error-free. Today, I aim to describe this process, providing you with a clearer understanding of how companies typically ship code to production.
Software: Code shipping cycle

For software product manager understanding the workflow of how companies deploy their software to production is vital. With countless tools and processes, the route from idea conception to a live product can appear intricate. Image below provided a remarkable snapshot of this journey. Let's delve into its depths and understand each stage step-by-step, so you can feel yourself confident in this process:

1. Plan

At this foundational stage, visions become tangible tasks.

Role: Product Owner

Action: On this phase product owner gather requirements, create and estimate user stories (with team) prioritize them and make risk assessment. Transforming overarching product goals into detailed user stories is the core activity here.

Tools used: Tools like Jira streamline this process, enabling better tracking and organization. Confluence often used for documentation.

Goal: A well-thought-out plan provides clarity, reduces ambiguities, and ensures that every team member understands their role and responsibilities. It acts as a reference point for further steps.

Example: Imagine wanting a new login feature. The product owner would create a story detailing the user's journey, possible error scenarios, and design elements.

2. Development

Where ideas turn into functional code.

Role: Developers


  • Task Analysis: Before diving into coding, developers spend a considerable amount of time understanding and analyzing user stories. This ensures that they have a clear vision of what needs to be built and the value it provides to the end-users.
  • Coding: Post analysis, developers employ various programming languages and tools tailored to the project's requirements. This is the phase where the developer's technical expertise and creativity come to the fore.
  • Version Control: As code is written, it's essential to track and manage changes. This is where version control systems like Git play a monumental role. With platforms like GitHub, GitLab, or Bitbucket, developers can collaboratively work, merge their code changes, and resolve conflicts in a structured manner.
  • Continuous Feedback: The development process isn't isolated. As code is committed, feedback mechanisms activate. This can be in the form of:
  • Peer Reviews: Fellow developers review the code to spot logical errors, ensure coding standards, and validate the approach.
  • Automated Systems: Tools like linters and static code analysis provide immediate feedback about code quality, potential vulnerabilities, and adherence to coding standards.
  • Prototyping & Mockups: For user interface (UI) intensive applications, developers might create prototypes or mockups. This helps in visualizing the end product and facilitates better user experience design.
  • Integration: As modules or features are developed, they need to be integrated with the existing codebase. This step ensures that new additions work in harmony with previously developed parts.
  • Documentation: Alongside code development, it's crucial to document the functionality, libraries used, and important algorithms. This not only helps in future code maintenance but also assists other developers in understanding the code's intent

Tools used: This is where version control systems like Git play a monumental role. With platforms like GitHub, GitLab, or Bitbucket, developers can collaboratively work. Also including IDE developers working in and software languages like Python or C

Goal: It is where theoretical concepts transition into practical implementations

Example: Developers would write code for the login feature, push it to GitHub for review, and incorporate any feedback received.

3. Build & Package

It's time to compile the code and get it ready for deployment.

Role: Build Engineers / DevOps Engineers


  • Compilation. Once the code is written, it needs to be transformed from high-level programming languages into machine-readable binaries. This is achieved through a process called compilation.
  • Continuous Integration (CI): CI platforms like Jenkins, Travis CI, or CircleCI play a pivotal role. As developers push code to the version control system, these platforms automatically trigger build processes. By doing so, they ensure that the code integrates seamlessly with the existing codebase and that no recent changes have broken the build.
  • Process: As part of the build process, unit tests are executed to ensure that individual components of the software function as intended. Tools like JUnit for Java or NUnit for .NET are used for this purpose. Alongside, code coverage tools such as JaCoCo evaluate how much of the codebase is being tested, ensuring that critical parts of the application are not left unchecked.
  • Quality assurance: Before packaging, it's vital to guarantee the code's quality. Tools like SonarQube inspect the code for potential vulnerabilities, bugs, and maintainability issues. This continuous inspection ensures that the code adheres to predefined quality standards and best practices.
  • Artifacts Storage:The packaged software, termed as an artifact, needs to be stored safely and systematically. Repositories like JFrog Artifactory or Nexus serve as vaults where these artifacts are versioned and stored, ready for deployment or further testing.

Key Tools:

  • Tools like Maven, Gradle, and Ant for Java, or MSBuild for .NET, are employed to automate the 1st compilation tasks.
  • Jenkins: A trusted ally for continuous integration, facilitating regular and automated code building.
  • JUnit and JaCoCo: These ensure that the software runs as expected and helps gauge how much of the code is under test, respectively.
  • SonarQube: Continuously inspects code quality, ensuring standards are met and maintained.
  • JFrog Artifactory: After the build process, the software artifacts find their home here, awaiting deployment.

Example: The login feature code would be sent to Jenkins, tested using JUnit, its quality assessed with SonarQube, and then stored in JFrog Artifactory.

4. Test

The software, once built and packaged, is subjected to rigorous testing to make sure it works as planned and validate its functionality, performance, security, and usability.

Role: QA Engineers / Test Engineers


It include 2 stages:

1) QA Testing: In the designated QA environment, activities like regression and performance testing are conducted.

  • Unit Testing: As touched upon in the Build & Package stage, unit testing evaluates individual components or functions of the software in isolation. It ensures that each atomic part behaves as expected. Tools like JUnit, pytest, or NUnit are typically utilized for this purpose.
  • Integration Testing: Once individual units are verified, integration tests check how these components interact with one another. It's paramount to ascertain that the combination of multiple units functions cohesively.
  • System Testing: Here, the complete software is evaluated in an environment that simulates real-world usage. It's an end-to-end testing form where the entirety of the application's functionalities and features are assessed.
  • Regression Testing: Checks that recent changes haven't adversely affected existing functionalities.
  • Security Testing: Identifies vulnerabilities and security flaws in the application.

2) UAT (User Acceptance Testing): Performed in the UAT environment, this ensures that the software behaves as the end-users expect in their computer environment, to avoid bugs that can exist only in some specific environment.

  • The goal is to validate that the software fulfills the business needs and is ready for release. Feedback from UAT is crucial as it often captures nuances that technical tests might overlook.
  • Note: Tools like Docker have revolutionized environment setups. They allow quick replication of environments such as Dev, QA, and UAT, ensuring consistent testing grounds. Moreover, these environments are often hosted on cloud platforms for scalability and accessibility.

Key Tools:

  • Docker allows to create environments.
  • JUnit for Java or NUnit for .NET are used for this purpose

Example: Our login feature would be tested in simulated real-world scenarios by QA teams and then in selected end-users environments.

5. Release

Finally, where the software meets its users.

Role: SRE (Site Reliability Engineering)


  • Deployment to Production: The packaged software, after clearing all testing stages, is introduced into the production environment. The method of deployment can vary — from traditional manual deployments to more modern automated deployments using tools like Kubernetes or Ansible.
  • Monitoring and Observability: Once live, the software isn't just left to its own devices. Monitoring tools are kept on its performance and behavior.  Such as SkyWalking and Prometheus provide real-time insights into software health, user activity, and potential issues.
  • Alerting and Issue Resolution: With the help of monitoring tools, any anomalies or unexpected behaviours are promptly detected. Systems like PagerDuty or Opsgenie can alert the responsible teams, ensuring rapid response and resolution. Site team address issues and maintain the software's optimal performance.

Advance deployment:

As a product manager you often will be planning advance deployment methods that will help you with risk mitigation and experimentation that is important during software development. These techniques include:

  • Feature Toggle: Allows teams to turn features on or off without needing to redeploy the software.
  • Canary Deployment: Introduces the new version to a subset of users before a full-scale rollout. This acts as an early warning system for any unforeseen issues.
  • A/B Testing: Lets companies test two different versions of a feature to determine which one performs better in terms of user engagement or other metrics.These strategies enable companies to mitigate risks and ensure that users always receive the best possible version of the software.

Example: Our login feature released firstly randomly to 5% of users, and satisfaction metrics measured during AB testing between these users and the 95% that still have site without new login feature, to make sure people use this new feature and there is no problems in usage.

In summary, this process encapsulates the end-to-end journey of software from planning to release. It underscores many tools and processes that ensure software is not only functional but also meets quality standards. By comprehending this workflow, businesses can better navigate the digital landscape, ensuring that they deploy code both safely and efficiently to production


In summary, this process encapsulates the end-to-end journey of software from planning to release. It underscores many tools and processes that ensure software is not only functional but also meets quality standards. By comprehending this workflow, businesses can better navigate the digital landscape, ensuring that they deploy code both safely and efficiently to production

Related News

May 1, 2024
Now, battery companies have huge production investments and have started building manufacturing facilities in North America, increasing production capacity and recreating the full supply chain. Let's visualize this supply chain of Lithium batteries
April 25, 2024
In this article, we delve into ERCOT from 2010 to 2023; we explore how the inherent variability of renewable energy sources—dependent on factors such as wind speed and sunlight availability—affects grid reliability, particularly during peak demand.
April 19, 2024
The effectiveness of using leading and lagging indicators largely depends on the talent within the team. Critical thinking, market awareness, and the ability to interpret complex data are essential skills for product managers.