CI/CD pipeline: what it is and how to set one up

CI/CD pipeline: wat het is en hoe je er een opzet
Date
November 16, 2026
Author
Isatis Group
Category
Blog
Read time
7 min read

Learn what a CI/CD pipeline is, which stages it has and how to set one up in six practical steps, from build and tests to deployment and monitoring.

It's Thursday afternoon and a release is scheduled. One developer builds the application on their own laptop, a second copies the files to the server by hand and a third quickly clicks through a few screens. Two hours later, something that worked fine yesterday is broken. Nobody knows which step was different from last time. If this sounds familiar, you're probably missing a pipeline.

A CI/CD pipeline is the automated route a code change takes from commit to production. It builds the application, runs the tests, checks quality gates and rolls out the release without manual steps. You set one up by first writing down your current release process, then automating build and tests, and only after that automating deployment.

What is a CI/CD pipeline and what does it consist of?

The abbreviation stands for two habits that together form one assembly line.

  • Continuous integration (CI): developers merge their work into a single codebase often. With every change, a server automatically builds and tests the code, so an error shows up within minutes instead of only at release time.
  • Continuous delivery (CD): the tested version is always ready to go live. Whether someone still presses a button after that is up to you.
  • Continuous deployment: one step further. Every change that passes all checks goes to production without manual approval.

The pipeline itself is a series of steps defined in a file, usually stored alongside the code in your version control. That makes the process repeatable and auditable: the same change follows the same route every time, and you can see who changed what.

The stages of a pipeline: from commit to production

Every team sets it up differently, but the basics almost always look like this:

  1. Commit and trigger. A developer commits a change, and the pipeline starts automatically.
  2. Build. The code is compiled or packaged, for example into a container, in a clean environment rather than on a laptop.
  3. Test. Unit tests run first because they're fast. Integration tests follow, and possibly end-to-end tests.
  4. Quality gates. Automated checks decide whether the change can move on, for example based on test coverage, code quality or known vulnerabilities.
  5. Deploy to test or staging. You see the change running in an environment that resembles production.
  6. Deploy to production. With approval or automatically, depending on how much you trust your tests.
  7. Feedback. The result goes back to the team, so a failed step is visible right away.

The order goes from fast to slow. You want to know about a failing unit test after two minutes, not after waiting forty minutes for an integration test.

How to set up a pipeline in six steps

If you try to build a fully automated pipeline in one go, you'll get stuck. Build it up in layers.

Step 1: Describe how a release works today

Write down every action, including what one person does from memory. Those invisible steps are often the reason a release goes wrong.

Step 2: Put everything in version control

Code, configuration and the pipeline file belong in one place, with a simple way of working such as short branches that quickly merge back into the main line.

Step 3: Automate build and tests first

Let every change trigger a build and run the existing tests, even if there are only a few. A small pipeline that runs every time is worth more than an elaborate one nobody trusts.

Step 4: Add quality gates

Agree with your team on the minimum a change has to meet. Keep it small and concrete, because a gate that gets ignored every day only costs time.

Step 5: Automate deployment

Deploy automatically to a test environment first, and only then to production. Work out in advance how you can roll back to the previous version within a few minutes. A pipeline without a way back makes releases scary.

Step 6: Measure and improve

Look at how long the pipeline takes, how often it fails and why. Slow or unreliable tests are the biggest reason teams start bypassing it.

Tests and quality gates: where the pipeline gets its value

The pipeline is only as good as the checks in it. Without tests, it just ships bugs faster. Aim for a sensible balance:

  • Plenty of fast unit tests that check the logic of each component.
  • Fewer integration tests that show components, databases and integrations work together.
  • A small set of end-to-end tests for the paths your business depends on, such as ordering or logging in.
  • Automated security checks on dependencies and configuration.

If your test coverage is low, that's no reason to wait, but it is a reason to build up testing alongside the pipeline. Quality assurance and testing help with that, because a pipeline without reliable tests gives you a false sense of security.

Infrastructure and monitoring are part of the deal

A pipeline that deploys neatly to a hand-configured server is still fragile. With infrastructure as code, servers, networks and permissions live in version-controlled files instead of in someone's memory. You can rebuild any environment from them, and every change gets the same review as application code. Common tools include Terraform, Ansible and Kubernetes.

If you use AI to draft something like a Terraform module, always have an engineer read it before anything is applied. That's how we work ourselves: the engineer stays in control.

Once a release is out, monitoring begins. Structured logging, metrics and alerting tell you quickly when error rates or performance change, so you hear about an outage from your monitoring and not first from a user. Set the alert thresholds together with the team, otherwise you get noise and eventually everyone ignores the notifications.

Security updates benefit too: a patch you can build, test and deploy automatically goes live faster.

Common mistakes when setting one up

  • Starting too big. A pipeline with twenty steps before the first one even runs never gets finished.
  • Flaky tests. If a test sometimes fails for no reason, the team learns to ignore the red alert.
  • Secrets in the code. Passwords and keys belong in secure storage, not in the pipeline file.
  • One person who knows everything. If only that one colleague can change the pipeline, you're just moving the problem.
  • No way back. Without a quick way to roll back, nobody dares to deploy on a Friday.
  • No maintenance. A pipeline is software and needs updates, cleanup and the occasional redesign.

At Isatis, the people who build the software also keep it running, so nothing falls between two vendors. Read how we design and automate pipelines, whether you're starting from scratch or improving what you already have.

Frequently asked questions

What is a pipeline in DevOps?

It's the automated link between development and operations. A code change is built, tested, checked and deployed without manual steps, so errors are caught earlier.

Is GitLab a CI/CD tool?

Yes, GitLab has CI/CD built in alongside version control. Other code platforms come with their own pipelines too. Your choice depends on what you already use and how much you want to manage yourself.

What is a pipeline in GitHub?

A pipeline that runs in GitHub itself, defined in files in your repository. It starts automatically on a commit or pull request, so you don't need a separate build server.

How long does it take to set up a pipeline?

That depends on your codebase, test coverage and environments, so we don't quote a fixed timeline. A simple start with building and testing is small; you build up the rest in layers afterwards.


Is your release process still full of manual work, or do you have a pipeline nobody dares to touch anymore? Schedule a 15-minute conversation via the contact page. You tell us what you want to achieve, and we'll tell you honestly whether we can help.


About the author: Jeroen Penninx, Director and co-founder of Isatis.

Share this article

Jack van Poll

Jack van Poll

Co-Founder, Isatis

Writes about nearshore engineering,
software partnerships and building teams that last.

Get in touch

Read next.

All articles