Building a CI/CD pipeline: key considerations

A continuous integration / continuous delivery (CI/CD) pipeline is a workflow that incorporates software development phases. It includes continuous processes for integration, testing, delivery, and software deployment. These processes are organized into one pipeline that produces high-quality, secure software in a reliable and fast manner.

The ideal CI/CD pipeline includes as many automated processes as possible, especially for testing. The goal is to ensure that code goes through extensive checks to identify potential quality and security issues during early stages when it is easier, faster, and cheaper to fix. The pipeline runs tests automatically and pushes code changes to production environments.

Components of a CI/CD pipeline

CI/CD pipeline consists of various automated processes and tools for building, testing, integrating, delivering, and deploying code. It uses pre-defined protocols and automated feedback loops to standardize integration and delivery.

CI/CD pipeline 

A CI/CD pipeline typically includes the following stages:

  1. Commit: A request to merge new code features with the codebase. It initiates pipeline processes.
  2. Build: This stage compiles and builds the new code into a runnable instance.
  3. Test: A testing suite automatically tests the code build. The suite can include unit, acceptance, smoke, and integration tests. You can run testing in one or multiple stages.
  4. Deliver / deploy: The pipeline integrates the approved code into the codebase, packages it, and pushes it to a staging or production environment. Code that goes to a staging environment requires manual tests and reviews before being pushed to production.

Here are the main benefits of CI/CD pipelines:

  1. Efficiency - CI/CD pipelines enable you to focus on writing new code and maintaining your existing code by eliminating or reducing the scope of manual builds, tests, and runtime configuration.
  2. Standardization - CI/CD pipelines allow you to codify and enforce integration, deployment, and delivery standards. Automating these processes ensures tasks are performed reliably and consistently.
  3. Availability - CI/CD pipelines make your update releases easy and uniform, and CD processes ensure that the most recent version always remains available.
  4. Visibility - CI/CD pipelines automatically log all processes, making them available for review anytime. Additionally, automated feedback loops ensure you can identify problem areas early on and quickly fix code and processes.

Key considerations

  1. Defining specific pipeline goals 

Before starting a project, it is important to ask what you hope to achieve with the CI/CD pipeline. Your specific goals may include shorter release cycles, improved software quality, and test automation. The CI/CD adoption strategy should include all these goals in a checklist, letting everyone understand the common objective and work towards achieving it.

  1. Use the pipeline to encourage collaboration

While automation is a major aspect of CI/CD, the pipeline must also include manual intervention in certain areas. Building an automated pipeline takes time, and teams need to adjust to new workflows. CI and CD refer to a DevOps mindset, not just a technical approach. 

All DevOps team members should take ownership of the pipeline and avoid development and testing silos. You should design the pipeline to encourage shared responsibility and involve the development team in the testing process, with testers guiding the developers.

  1. Securing the pipeline

Baking security into the CI/CD pipelines is essential for securing your applications and managing security as an integrated process within your delivery workflow. It allows you to detect and resolve security issues quickly. 

One way to achieve this is to embrace DevSecOps and integrate security into your DevOps practices, encouraging collaboration between developers and security engineers. An important part of any DevSecOps strategy is open source security, which verifies that open source components used as part of a software project are high quality, secure, and do not represent legal exposure due to copyleft licenses.

Integrating security into the pipelines involves applying security checks at each key CI/CD stage: 

  1. Source code scans - scan code for vulnerabilities during the writing stage. 
  2. Security tests - run alongside performance tests before deploying each build.
  3. Security monitoring at runtime - continues after deployment, detecting and responding to security threats in the production environment.
  4. Streamlining tests

CI/CD requires automated testing for software quality assurance, but it is not practical to test all possible eventualities. The CI/CD pipeline should provide rapid feedback, balancing test coverage and speed requirements. Testing is more efficient if you run automated tests first and reserve slower, manual tests for when you have more confidence in your build. 

The first round of testing should include automated unit tests with broad coverage, alerting you to obvious issues. The next testing layer may include component or integration tests to examine code interactions. An additional layer might include automated complex tests like GUI, performance, and load tests. Only the last testing stage should involve manual testing (i.e., acceptance testing) focusing on high-risk areas.

  1. Keeping the testing environments clean

Cleaning the pre-production environments can take time but will make testing more efficient. Long-running environments are difficult to manage given the various updates and configurations applied and the divergence from the original environment over time. The state of each environment is important for ensuring the tests return reliable results. 

Container-hosted environments are easier to spin up and decommission between deployments with an infrastructure-as-code (IaC) approach. You can use a new container to scale tests and ensure consistency for each new environment.

CI/CD pipeline 


In this article, I explained the basics of CI/CD pipelines and introduced five considerations for building an effective pipeline:

  1. Defining specific pipeline goals - identify what is important for your organization and balance goals like development velocity, quality, and security.
  2. Encourage collaboration - ensure that development and operations teams take joint ownership over the pipeline in a true DevOps spirit.
  3. Securing the pipeline - scan source code, watch for vulnerable open source components, and perform security testing at every stage of the software lifecycle.
  4. Streamlining tests - automate testing as much as possible to ensure high quality without slowing down the pipeline..
  5. Keep test environments clean - automatically set up test environments on demand using IaC to ensure predictable test results.

I hope this will be useful as you advance towards a fully automated CI/CD development process.