What Is CI/CD? Continuous Integration and Delivery Explained

Years ago, teams shipped software every few months. Developers worked alone for weeks, merged everything at the end and spent days fixing the clashes. CI/CD grew out of that pain: make changes small, check them automatically and release them constantly.

This guide explains what CI/CD is without jargon, and ends with a file you can paste into a real project.

What CI/CD means

CI/CD stands for continuous integration and continuous delivery (or continuous deployment). It is a set of practices backed by automation tools, usually part of a wider DevOps approach.

The goal is simple: whenever someone changes the code, a system proves that the change still works and, if you choose, ships it.

Continuous integration (CI)

With CI, every developer merges their work into the shared branch often, often several times a day. Each merge triggers an automatic job that builds the project and runs the tests. If something fails, the team sees it within minutes, while the change is still fresh in the author’s mind.

Good CI depends on good habits: small pull requests, a clear branching approach (see Git merge vs rebase) and tests that are fast and reliable.

Continuous delivery vs continuous deployment

The two CDs differ by one decision: who presses the release button.

Most teams begin with continuous delivery and move to continuous deployment only when their tests and monitoring are strong enough to trust.

What a CI/CD pipeline does

A pipeline is a series of automated stages. If one stage fails, the pipeline stops, and the change does not move forward.

1. Source: a commit or pull request triggers the run.
2. Build: compile the code or build a container image.
3. Test: unit tests first, then integration and end-to-end tests. See our end-to-end testing best practices.
4. Package: create the artifact you will release, such as an image or a bundle.
5. Deploy: send it to staging, then to production.
6. Monitor: watch errors and performance, and roll back if needed.

Many pipelines build containers. If that is new, read our Docker tutorial for beginners and the Docker Compose tutorial for running dependent services.

A working example

This is a complete CI workflow for GitHub Actions. It checks out the code, installs dependencies and runs the tests and the build on every pull request and on every push to main.

# .github/workflows/ci.yml
name: CI
on:
  pull_request:
  push:
    branches: [main]

jobs:
  build-test:
    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 test
      - run: npm run build

Commit the file and open a pull request. GitHub shows a green check or a red cross next to your commit. For a deeper walkthrough with secrets, caching and deployment, see our GitHub Actions CI/CD guide, or run browser tests in it with the GitHub Actions Playwright workflow.

Benefits and costs

• Faster feedback: you learn about a broken change in minutes, not weeks.
• Smaller risk: small releases are easier to understand and to undo.
• Consistent releases: the same steps run every time, with no “works on my machine”.
• Less manual work: people stop copying files and clicking through checklists.

The costs are real too: someone must maintain the pipeline, slow or flaky tests waste time, and the team needs the discipline to fix a red build immediately.

How to start with CI/CD

1. Put your code in a shared repository and use pull requests.
2. Add the smallest useful workflow: install, test, build.
3. Make the tests fast. Keep the pipeline under ten minutes if you can.
4. Require the pipeline to pass before a pull request can be merged.
5. Add automatic deployment to a staging environment, then to production when you trust it.

Final thoughts

CI/CD is not a product you buy, it is a way of working supported by automation. Start with one file that runs your tests, then grow the pipeline one stage at a time.

Frequently asked questions

Keep learning