StackLift
All terms

Glossary

CI/CD

Automated building, testing, and deploying of code on every change.

CI/CD (continuous integration / continuous delivery) is the practice of automatically building, testing, and deploying code on every change, so releases are frequent, repeatable, and low-risk instead of manual and error-prone.

A real pipeline includes automated tests, environment separation (dev/staging/prod), and a safe promotion + rollback path. StackLift treats CI/CD as part of every build, not an afterthought.

Start in 60 seconds

Put this to work on your project.

Get an AI-assisted, architect-reviewed scope, cost range, and timeline. Free, no login.

The complete guide

CI/CD: the complete guide

Updated November 18, 2026 ยท Published by , Founder, StackLift AI. Written with AI assistance; how we make content.

Short answer

CI/CD is the practice of automatically building, testing, and releasing code every time it changes. Continuous integration merges small changes often and checks each one with automated tests. Continuous delivery keeps every passing change ready to release, and continuous deployment pushes it to users without a manual step. Together they make releases routine instead of risky.

What is CI/CD in simple terms?

Think of CI/CD as an assembly line for code. A developer finishes a small change and sends it to the shared repository. A server picks it up, builds the app, runs the tests, and reports pass or fail within minutes. If it passes, the same line carries it toward your users.

The two halves solve different problems. Continuous integration (CI) catches broken code early, while it is still small and fresh in someone's mind. Continuous delivery (CD) removes the manual, error-prone steps between a passing build and a live release.

The letters "CD" mean two things in practice, which confuses a lot of buyers. Continuous delivery keeps a human approval before production. Continuous deployment has no approval step and ships every passing change on its own.

How does a CI/CD pipeline work?

A pipeline is a series of automated stages that run in order. If any stage fails, the pipeline stops and tells the team what broke. Nobody has to remember a checklist, because the checklist is the pipeline.

  1. Commit: a developer pushes a change on a feature branch and opens a pull request.
  2. Build: the pipeline compiles the code and installs dependencies in a clean environment.
  3. Test: unit, integration, and end-to-end tests run, along with linting and security checks.
  4. Review: a code review and any required approvals happen before the change merges.
  5. Stage: the build goes to a staging environment that mirrors production.
  6. Release: the change is promoted to production, often gradually, with a rollback path ready.
  7. Watch: observability confirms the release is healthy.

CI/CD examples

A web app team uses a hosted pipeline such as GitHub Actions or GitLab CI. Every pull request runs the test suite and builds a preview link, so reviewers can click through the change before it merges. Merging to the main branch deploys to staging, and a button or a tag promotes it to production.

A mobile team uses the same idea with a different last step. The pipeline builds signed app packages and uploads them to a testing channel, and the store release stays a deliberate human choice.

A data or AI team adds model and prompt checks. The pipeline runs a fixed set of test cases against the new prompt or model version and blocks the release if answers get worse.

Why does CI/CD matter when you buy or build software?

Without a pipeline, every release is a small event that depends on one person's memory. Releases get bigger and rarer, and bigger releases break more. With a pipeline, releases are small and frequent, so problems are easier to find and cheaper to fix.

It also affects cost and risk in ways a quote does not always show. Adding a pipeline late means retrofitting tests onto code that was never written to be tested. Planning it from the start is cheaper, and it protects you from being locked to the one engineer who knows how to deploy. See the production readiness checklist for what to ask a vendor, and the cloud and DevOps cost page for what drives the effort.

Common CI/CD mistakes and misconceptions

Mistakes that make a pipeline look good but protect nothing
MistakeWhy it hurtsBetter practice
Few or no automated testsA green build proves nothingTest the paths that earn or lose money first
Slow pipelinesPeople skip or work around themRun quick checks first, slow ones later
Secrets in the repositoryAnyone with code access can read themKeep secrets in a managed store, injected at deploy time
No rollback planA bad release becomes an outageMake rollback a tested, one-step action
Deploying straight to productionNo place to catch environment-specific bugsPromote through staging every time

A common misconception is that CI/CD means releasing constantly. It does not. It means you can release safely whenever you choose, and that choice stays with you.

How StackLift uses CI/CD

At StackLift AI, CI/CD, observability, security review, and rollback are part of the plan from sprint one, not a later add-on. Agents work on feature branches and never push to the default branch or touch production secrets. Engineers review changes before they merge.

You see releases in the client portal alongside approvals and invoices. To see how the work is scoped, run the free estimate, or read how an AI software factory fits into delivery.

What does each stage of a pipeline actually check?

A pipeline is only as useful as the checks inside it. Teams often say they have CI/CD when they have a build that compiles and nothing more. The table below shows what each kind of check protects you from, so you can ask for the right ones.

Common pipeline checks and what they catch
CheckWhat it catchesWhen it runs
Linting and formattingStyle problems and some simple bugs, such as unused variablesOn every commit, in seconds
Type checkingMismatched data shapes before the code runsOn every commit
Unit testsLogic errors inside one function or componentOn every commit
Integration testsParts that work alone but fail together, such as code and databaseOn every pull request
End-to-end testsBroken user journeys like sign-up or checkoutOn pull requests or before release
Dependency and secret scansKnown-vulnerable packages and leaked keysOn every pull request, and on a schedule
Smoke tests after deployA release that built fine but does not startRight after each deploy

Fast checks run first so developers get quick feedback. Slow checks run later, or only on the changes that need them. A pipeline that takes too long teaches people to ignore it.

What deployment strategies does CD support?

Continuous delivery does not say how a release reaches users. Several patterns exist, and each trades speed against safety. The right one depends on how costly a bad release is for your product.

Release strategies compared
StrategyHow it worksBest when
Rolling updateServers are replaced a few at a timeMost web apps with stateless servers
Blue-green deploymentA full second environment goes live, then traffic switches overYou need instant rollback
Canary releaseA small group of users gets the new version firstThe change is risky or hard to test fully
Feature flagsCode ships turned off and is enabled later for chosen usersYou want to separate deploying from releasing

Feature flags deserve special mention. They let you merge unfinished work safely, because the code stays hidden until it is ready. This keeps branches short, which is the whole point of continuous integration.

Does CI/CD work differently for AI and data projects?

The principles are the same, but AI projects add things that a normal test suite cannot see. A change to a prompt, a model version or a retrieval setting can change answers without touching any application code. The pipeline needs checks for that.

  • Evaluation sets: a fixed list of questions with expected behavior, run against each new prompt or model version. See agent evaluation.
  • Guardrail tests: cases that try to push the system into unsafe or off-topic answers, related to prompt injection.
  • Cost checks: a warning when a change makes each request use many more tokens.
  • Data checks: tests that a data pipeline still returns the shape and freshness the app expects.
  • Staged rollout: new models reach a small share of traffic first, with observability watching quality.

Treat prompts and model settings as code. Keep them in the repository, review them, and release them through the same pipeline. That makes every change visible and reversible.

How do you set up CI/CD for a new project?

You do not need a perfect pipeline on day one. You need a small working one that grows with the product. This order keeps the effort proportional to the risk.

  1. Put all code and configuration in version control, with one protected default branch.
  2. Add an automated build that runs on every pull request in a clean environment.
  3. Add the first tests for the paths that earn or lose you money, then add checks as bugs appear.
  4. Create separate development, staging and production environments with their own secrets.
  5. Automate deploys to staging on merge, and make promotion to production one deliberate action.
  6. Write and rehearse the rollback step before you need it.
  7. Add monitoring and alerts so a bad release is noticed in minutes, not days.
  8. Review the pipeline every few months and remove checks nobody trusts.

How do you know your CI/CD pipeline is working?

Four signals, usually called delivery metrics, tell you whether the pipeline helps. You can read them without special tools, and none needs a target number to be useful. Look at the direction over time.

  • Deployment frequency: how often changes reach production. Rising frequency with steady quality is healthy.
  • Lead time: how long a change takes from commit to live. A shrinking lead time means fewer waiting steps.
  • Change failure rate: how often a release causes a problem. It should stay flat or fall as releases speed up.
  • Time to restore: how quickly you recover after a failure. This is where rollback pays off.

Also watch softer signs. If engineers avoid merging on Fridays, or release notes are written by hand the night before, the pipeline is not yet doing its job.

What does CI/CD mean for cost and timeline?

The effort depends on how many environments you run, how much test coverage already exists, how many services deploy separately, and what compliance evidence you must produce. A single web app with a small test suite is quick to automate. A system with several services, mobile apps and a data layer takes longer.

Building the pipeline with the product costs less than adding it afterward, because tests written alongside code are cheaper than tests retrofitted to it. See the cloud and DevOps cost page for the factors, and run the free estimate to see how deployment work shows up in a plan. Most first versions take 6 to 16 weeks depending on scope, and the pipeline is part of that time, not extra.

Which tools are commonly used for CI/CD?

Tool categories and examples
CategoryExamplesWhat it does
Pipeline runnersGitHub Actions, GitLab CI, CircleCI, Jenkins, Azure DevOpsRun builds, tests and deploy steps
Hosting with built-in deploysVercel, Netlify, AWS AmplifyBuild and release on each push, with preview links
Containers and orchestrationDocker, Kubernetes, Argo CDPackage apps and keep clusters matching the repository
Infrastructure as codeTerraform, Pulumi, AWS CloudFormationCreate environments from reviewed files
Quality and security scanningSonarQube, Dependabot, Snyk, TrivyFind bugs and vulnerable packages automatically

Pick tools your team can maintain. A simple pipeline everyone understands beats a clever one only one person can fix.

Questions people ask

Is CI/CD only for large teams?

No. A single developer benefits too, because the pipeline runs the tests and the deploy steps the same way every time. Small teams often gain the most, since they have no spare person to catch mistakes by hand.

What is the difference between continuous delivery and continuous deployment?

Continuous delivery keeps every passing change ready to release but waits for a person to approve the push to production. Continuous deployment removes that approval and releases automatically. Teams pick based on test coverage and how much risk the product can carry.

Which tools are used for CI/CD?

Common choices include GitHub Actions, GitLab CI, CircleCI, Jenkins, and the build systems built into hosts such as Vercel, AWS, and Azure. The tool matters less than having reliable tests and a clear promotion path.

Can CI/CD be added to an existing app?

Yes, though it takes work if the code has no tests. The usual path is to start with a build and a few critical tests, then grow coverage over time. A production rescue often starts exactly here.

Does CI/CD make software secure?

Not by itself. It gives you a place to run security scans, dependency checks, and required reviews on every change. The checks only help if someone chooses them and acts on the results.

Who owns the pipeline after delivery?

You should. Pipeline definitions live in your repository, so any engineer can read and change them. Ask any vendor to confirm that before you sign.

How long does it take to set up CI/CD?

A basic pipeline for a simple app can be working in a few days. A fuller setup with several environments, security scans and rollback takes longer and grows as the product does. It is best built alongside the first sprints rather than saved for later.

Is CI/CD the same as DevOps?

No. DevOps is a way of working that joins development and operations. CI/CD is one of its main technical practices, the automated path from commit to release.

Do I need CI/CD for a prototype or MVP?

A light version still pays off. Even a build, a handful of tests and a one-click deploy stop a small team from breaking the demo the night before. You can add depth after you learn what users want. See MVP.

Sources

Sources and further reading

The standards, rules, research and official documentation this page draws on.