Introduction to CI/CD

CI/CD automates the path from code commit to production deployment. It catches bugs early, eliminates manual deployment errors, and lets teams ship software faster and more confidently.

What is Continuous Integration (CI)? link

Every code change triggers an automated pipeline:

  git push  →  Build  →  Test  →  Lint  →  Report
  

Developers integrate code into a shared repository multiple times per day. Each integration is verified by an automated build and test suite.

Benefits:

• Bugs found within minutes, not days
• No “integration hell” at release time
• Always have a known-good build

What is Continuous Delivery (CD)? link

Continuous Delivery extends CI — code is always in a deployable state:

  CI pipeline  →  Staging deploy  →  Manual approval  →  Production
  

Continuous Deployment goes further — every passing build deploys to production automatically (no manual gate).

Most teams start with CI, add CD to staging, then automate production when confidence is high.

The CI/CD Pipeline link

  ┌─────────┐   ┌───────┐   ┌──────┐   ┌────────┐   ┌──────────┐
│ Trigger │ → │ Build │ → │ Test │ → │ Deploy │ → │ Monitor  │
│ (push)  │   │       │   │      │   │ staging│   │          │
└─────────┘   └───────┘   └──────┘   └────────┘   └──────────┘
                                          │
                                     ┌────▼────┐
                                     │ Deploy  │
                                     │  prod   │
                                     └─────────┘
  

Typical Stages link

1. Trigger — push to branch, Pull Request opened, tag created
2. Build — compile code, build Docker image
3. Test — unit, integration, end-to-end tests
4. Quality gates — lint, security scan, code coverage threshold
5. Deploy staging — automatic on merge to main
6. Deploy production — manual approval or automatic with feature flags
7. Monitor — alerts if error rate or latency spikes post-deploy

CI/CD Without Automation (The Old Way) link

  Developer commits → waits for weekly build → QA tests manually →
  ops deploys Friday night → something breaks → rollback manually
  

Problems: slow feedback, fear of deploying, big-bang releases, weekend firefighting.

CI/CD With Automation link

  Developer pushes → CI runs in 5 minutes → PR blocked if tests fail →
  merge to main → auto-deploy staging → smoke tests pass →
  one-click production deploy → monitoring confirms health
  

Key Concepts link

Example — Node.js CI Pipeline link

Conceptual GitHub Actions workflow:

  name: CI
on: [push, pull_request]

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

Every push and PR runs lint + tests. Merge is blocked if CI fails (via branch protection).

Branch Strategy + CI/CD link

  feature branch  →  PR  →  CI runs  →  review  →  merge to main  →  CD deploys
  

• Feature branches trigger CI on PR
• Main branch triggers CD to staging/production
• Tags (v1.0.0) trigger release builds

CI/CD Tools link

Metrics That Matter link

(DORA metrics — DevOps Research and Assessment)

What Comes Next link

Implement pipelines with GitHub Actions or Jenkins, then apply CI/CD Best Practices for production-grade delivery.