CI/CD

CI/CD is a set of software engineering practices that automate building, testing, and releasing code. Continuous Integration (CI) merges and validates code changes frequently, while Continuous Delivery or Deployment (CD) automates pushing those validated changes to staging or production through a repeatable pipeline.

CI vs CD: two linked but distinct practices

The acronym bundles three practices that operate in sequence. Continuous Integration covers the developer-facing side: every commit triggers an automated build and test run so integration problems surface within minutes rather than during a painful end-of-sprint merge. Continuous Delivery extends this by keeping the application in an always-releasable state, with deployment to production requiring a manual approval. Continuous Deployment removes that manual gate entirely, shipping every change that passes the pipeline straight to production.

The two meanings of the second "C" are frequently confused. The distinction is the human approval step:

AspectContinuous Integration (CI)Continuous Delivery (CD)Continuous Deployment (CD)
ScopeBuild and test on every commitKeep the build release-readyAuto-release to production
TriggerCode push or pull requestSuccessful CI runSuccessful CI run
Production releaseNot handledOne-click, manual approvalFully automated, no gate
Main goalCatch integration defects earlyMake releases low-risk and routineShorten lead time to zero manual steps

Pipeline stages

A CI/CD pipeline is a defined sequence of automated stages. A failure at any stage stops the pipeline and reports back to the team, so broken code never advances. A typical layout includes:

  • Source: a commit, merge, or pull request to the version control system triggers the run.
  • Build: the application is compiled and dependencies resolved, often producing an artifact or container image.
  • Test: automated unit, integration, and sometimes end-to-end tests validate the build; static analysis and security scans frequently run here.
  • Release: the validated artifact is published to a registry or staging environment.
  • Deploy: the artifact is promoted to production, either after manual approval (delivery) or automatically (deployment).

Common tooling includes GitHub Actions, GitLab CI/CD, Jenkins, and CircleCI, usually paired with container registries and infrastructure-as-code so each run is reproducible.

Why it matters for software projects

For a business application, the value of CI/CD is operational predictability rather than novelty. Automating the build-test-release path reduces the manual handling that introduces human error, and it shortens the feedback loop between writing code and confirming it works in a production-like environment.

Concrete benefits for an engineering team include:

  • Defects are caught close to the change that caused them, where they are cheapest to fix.
  • Releases become small and frequent rather than large and risky, simplifying rollback.
  • The pipeline acts as living documentation of how the software is built and deployed.
  • Quality gates such as test coverage thresholds and security scans are enforced consistently, not left to discipline.

Questions fréquentes

Both keep the application in a releasable state after passing the pipeline, but they differ at the final step. Continuous Delivery requires a human to approve the push to production, giving teams control over timing. Continuous Deployment removes that gate, so every change that passes all tests is released automatically.

No. Even a solo developer benefits from automated builds and tests on every commit, because the pipeline catches regressions and enforces consistency. The practice scales with team size, but the core value of fast, reliable feedback applies to projects of any scale.

Popular platforms include GitHub Actions, GitLab CI/CD, Jenkins, and CircleCI. These orchestrate the pipeline stages and integrate with version control, test frameworks, container registries, and deployment targets. The right choice usually depends on where the source code is hosted and the existing infrastructure.

Not entirely. CI/CD automates repeatable checks such as unit, integration, and security tests so they run on every change. Exploratory testing, usability review, and complex acceptance scenarios still benefit from human judgment, and a mature pipeline complements rather than eliminates those activities.

Building a custom software project? We design bespoke software aligned with your roadmap.

See our custom software expertise

Définitions liées

← Retour au glossaire