CI vs CD vs Continuous Deployment

Continuous Integration

Continuous Integration (CI) is the practice of merging code changes into a shared repository frequently, with each merge triggering an automated build and test sequence. The goal is to catch integration errors early, before they compound into larger problems.

A CI pipeline typically runs on every pull request and merge to main. It compiles code, runs unit tests, checks formatting, and produces build artifacts. If any step fails, the pipeline stops and developers are notified immediately.

name: CI
on: [push, pull_request]

jobs:
  ci:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-node@v4
        with:
          node-version: "20"
          cache: "npm"
      - run: npm ci
      - run: npm run lint
      - run: npm test
      - run: npm run build

Continuous Delivery

Continuous Delivery (CD) extends CI by ensuring that code is always in a deployable state. After the CI steps pass, the pipeline produces a release artifact and may deploy it to staging. However, production deployment requires manual approval.

name: CD
on:
  push:
    branches: [main]

jobs:
  build:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - run: npm ci && npm test && npm run build
      - uses: actions/upload-artifact@v4
        with:
          name: dist
          path: dist/

  deploy-staging:
    needs: build
    runs-on: ubuntu-latest
    environment: staging
    steps:
      - uses: actions/download-artifact@v4
        with:
          name: dist
      - run: ./deploy-staging.sh

  deploy-production:
    needs: deploy-staging
    runs-on: ubuntu-latest
    environment:
      name: production
      url: https://app.example.com
    steps:
      - uses: actions/download-artifact@v4
        with:
          name: dist
      - run: ./deploy-production.sh

Continuous Deployment

Continuous Deployment goes further than Continuous Delivery by automatically deploying every change that passes the pipeline to production. There is no manual approval step. This requires high confidence in automated testing, monitoring, and rollback mechanisms.

stages:
  - build
  - test
  - deploy

build:
  stage: build
  script:
    - npm ci && npm run build
  artifacts:
    paths: [dist/]

test:
  stage: test
  script:
    - npm test
  needs: [build]

deploy:
  stage: deploy
  script:
    - ./deploy.sh production
  needs: [test]
  when: on_success
  environment:
    name: production

Comparing the Three

Maturity Model

Most organizations progress through these levels over time. Jumping directly to continuous deployment without solid CI and testing practices leads to frequent production incidents.

1. Level 0: Manual builds and deploys — no automation, long release cycles, frequent hotfixes.
2. Level 1: CI — automated builds and tests on every push, but manual deployment.
3. Level 2: Continuous Delivery — automated artifact creation and staging deploys, manual production approval.
4. Level 3: Continuous Deployment — fully automated pipeline from commit to production with monitoring and rollback.

Choosing Your Level

Continuous Delivery is the right default for most teams. It gives you fast, automated validation while keeping a human checkpoint before production. Continuous Deployment is appropriate when you have comprehensive test coverage, reliable monitoring, and fast rollback capabilities.