The book that made deployment an engineering discipline: an automated pipeline, boring releases, from commit to production without the pain.
Why this book
A pipeline, the automatic chain that tests then deploys every change, and a release that is no big event: this has become routine. The book that wrote it down in 2010 is Continuous Delivery, by Jez Humble and David Farley. I work at a crypto fintech, where deploying is part of my job, and much of what I practice comes from it.
It completes a trio in my library. The Phoenix Project tells the hell of deployment as a novel. Accelerate proves with numbers that shipping often and shipping well go together. Continuous Delivery gives the recipes: the how, between the story and the proof. In order: novel, proof, manual.
The ideas that stick
The book is a thick enterprise manual, and it owns it. Here are the eight ideas worth carrying out of it.
1A release should not be scary
The book opens on a scene everyone has lived through: the whole team there for an entire weekend, red-eyed in front of a screen at 2 a.m. They are trying to work out why the release to production is stuck, the moment the new version reaches the real servers, the ones customers use. The authors name three bad habits that lead there.
- Deploying by hand: every step performed by a person, so human error at every turn.
- Trying the software on a copy of the real servers only at the very end: the operations teams, who run the servers, first see it on release day. The surprises pour in.
- Configuring production by hand: a setting changed straight on the server, never recorded, impossible to reproduce.
The sentence that sums up their anger: "Releasing software is too often an art; it should be an engineering discipline."
Their proof is one anecdote. One of their clients tied up a whole team for seven days, weekends included, for every release, with a poor success rate. After automating the deployment, the last release they observed took seven seconds. Nobody noticed a thing, except that the new features were suddenly there. The goal of the book: make releases boring.
2The deployment pipeline, from change to production
To make releases boring, the book relies on a central concept, the one that gives it its subtitle. Continuous integration (CI) means rebuilding and retesting the application on every change, so it stays in working order at all times. The deployment pipeline takes that idea all the way to production.
Every change (code, configuration, environment, data) triggers a new pipeline in four stages, which the diagram below shows: the "commit stage", the automated business tests, the sign-off, then the release to production. The first compiles and runs the fast unit tests, the ones that check each small piece of code. It also builds the program, ready to run. If it passes, you get a "release candidate", stored in a warehouse for files. The next stages give it confidence. The business tests check that the features work, the sign-off (UAT) is the validation by representatives of the users. As soon as a stage fails, everything stops until it is fixed.
The clever part: the pipeline is a pull system. A tester, an operations engineer or a manager serves themselves: they pick the version and the environment (the set of servers targeted: developer machine, staging or production), and press a button. No more begging a developer for a deployment or waiting for the nightly build.
To judge a pipeline, the book borrows a question from Mary and Tom Poppendieck. "How long would it take your organization to deploy a change that involves just one single line of code?" The longer the answer, the heavier the process.
3If it hurts, do it more often
The pipeline is a tool. Behind it, the book lays down a simple rule, the easiest to remember. If an activity hurts, do not put it off: do it more often, and right away. The opposite reflex, avoiding it, lets the pain grow. Three examples:
- Integrating code from several developers is painful? Integrate on every change, from day one of the project, instead of waiting for one painful merge at the end.
- Testing is scary just before going to production? Test continuously from the start.
- Documentation is a chore? Write it as you build each feature.
What makes the rule work is that a task repeated on every change stays small, then becomes automatic. The authors call it "bring the pain forward": move the effort early in the cycle, where a mistake is cheapest to fix. Deployment is the example. The seven days of manual release in idea 1 become seven seconds: by dint of deploying on every change, everything got automated.
The idea is not new, and the authors say so. Extreme Programming (the 2000s agile method that pushes practices like continuous testing and integration to the extreme) already applies it to development. Their book applies it to deployment. What follows gives the concrete rules.
4Build once, deploy the same way everywhere
Here are the three concrete rules that make deployment repeatable without pain.
- Build only once. The program made at the first stage of the pipeline (the "commit stage") is the only one that travels, unchanged, from one environment to the next up to production. Recompiling at each step risks another version of the compiler or of a library, so a program subtly different from the one you tested. The exact sentence: "The binaries that get deployed into production should be exactly the same as those that went through the acceptance test process." Some pipelines even check the program's fingerprint at each stage, a code computed from the file, which changes if a single byte changes.
- Deploy the same way everywhere. One deployment script serves the developer's machine, staging and production. Only a configuration file changes from one environment to the next.
- Put everything in version control. Everything you need to build, deploy, test and release goes into the repository. A new joiner should be able to clone it and rebuild everything with a single command.
The second rule has a powerful consequence: the path to production has been tested hundreds of times before the big day. If something breaks in production, you know it is that environment's configuration, not the script. An example of my own, not the book's: the same script, which reads config/staging.env or config/prod.env depending on its argument.
./deploy.sh staging
./deploy.sh prod
5"Done" means "released"
These rules serve a demanding definition of "done". How often have you heard a developer say a feature is done? For the authors, it is only done when it delivers value to users: "in production" means here delivered, in their hands. Not when the code compiles, not when it works "on my machine". And there is no "80% done": a thing is either done or it is not.
That changes who carries the responsibility. "Done" does not rest on one person. It takes testers, operations engineers (the people who run the servers) and developers, together, from start to finish. No more developer throwing code over the wall to testers, who throw it to operations on release day. The whole team owns delivery.
Behind it sits another principle, borrowed from the lean movement (the production method born at Toyota) and from W. Edwards Deming, a pioneer of industrial quality: "build quality in". The direct consequence: testing is not a phase you bolt on after development, it is a continuous activity that belongs to everyone.
What remains is how to go to production without risk: that is the next idea.
6Deploying is not releasing
To go to production without risk, the book separates two acts that are often confused. Deploying means putting the program in place on the servers. Releasing means making it visible to users. A deployed version is seen by nobody until you send people to it: releasing becomes a decision, not a risky operation. This is the chapter I use most, and the least dated in the book.
Three techniques put this into practice.
- Blue-green: two identical copies of production, the blue one and the green one. The router (the switch that spreads visitors across servers) sends all traffic to green. You deploy the new version to blue and smoke-test it (with no users), then flip the router to blue. The switch takes "much less than a second". A problem? You flip back to green.
- Canary releasing: you deploy the new version to a handful of servers only. The router sends just a small fraction of users there. "Like a canary in a coal mine", it surfaces problems fast without touching the majority. If the health measures (errors, slowness) look good, you widen; if not, you cut.
- Rollback: either you keep the old version deployed and ready to resume, or you redeploy a known-good version. The process is the same, tested a hundred times.
One iron rule runs through the chapter: an emergency fix goes through the same pipeline as everything else. Bypassing it "because it is urgent" means putting an untested fix into production, in an environment whose state you no longer know, since that fix did not follow the usual path.
What remains is where everyone works before this pipeline: on which branch of the code. That is the next idea.
7Long branches kill integration
The book's sharpest stance, the one that still sparks debate, is about where everyone writes their code. A few terms first: the trunk is the shared version of the code, a branch is a parallel copy where you work apart, and a commit records your changes. The authors' verdict: "branching is fundamentally antithetical to continuous integration."
The reasoning is short. If everyone works on their own branch, one per feature, by definition nobody integrates their work with the others'. Running continuous integration on each branch in isolation changes nothing: each is tested alone, never with the others. Branches drift from the trunk, and on merge day you reap massive conflicts: incompatible changes to the same lines. Their advice fits in one practice: "Always commit to trunk, and do it at least once a day."
For a big change that feels too scary to integrate in one go, they offer branch by abstraction (a name coined by their colleague Paul Hammant). Instead of a branch, you add a layer of abstraction in the code, a common interface behind which the implementation is hidden. You swap the old implementation for the new one little by little, on the trunk, without ever breaking the compilation or the tests.
An example of my own: to change payment provider, you write a common interface. You plug the old and the new provider into it, then switch when the new one is ready. A few branches stay tolerated: one for a published version, and the throwaway experiment branch.
This idea aged in a curious way. Git, the version-control tool that became the standard, was young in 2010, and the authors were wary of it for the enterprise (rewritable history, slipperier audit). Git has taken over. But their substance, develop on the trunk rather than on long branches, is what the "trunk-based development" movement champions today.
What remains is a case that code alone does not cover: data. That is the next idea.
8The database gets versioned too
Code can be redeployed at will. Data cannot: it survives deployments and rollbacks. The book's answer: automate migrations, the scripts that change the structure of the database (adding a column, for example). Each version of the schema (the structure of the tables) has its versioned scripts, one "roll forward" and one "roll back" script.
The point is to change the structure of the database without tying it to the application deployment. During the switch, the old and the new version of the code read the same database. A well-designed migration is compatible with the old and the new version of the code, for the duration of the switch. Without that, blue-green and canary fall apart. You cannot flip a router in under a second if the database itself is changing shape.
An example of my own: the new version needs a "phone" column. You add it first as optional, which the old code ignores. You deploy the new code, and only later do you make the column mandatory. The authors point to Refactoring Databases (Ambler and Sadalage) for patterns of this kind. In my view, this is the real hard part of continuous delivery, in 2010 as today.
My take, honestly
My verdict, 7.6 out of 10: a manual whose tools have aged, but whose principles still hold. It gave me the why behind the moves I make every day: why a single program travels from one environment to the next, why the same script everywhere, why you deploy without releasing. With those reasons, you stop hacking and start designing.
Its strength: it turns a pile of practices into one coherent discipline, with a central idea that is easy to remember, the pipeline, and concrete rules behind it.
Two reservations, with what they change for you:
- The tooling is dated. Hudson, Ant, CruiseControl: mentally swap in GitHub Actions, Docker (containers that package the application), Kubernetes (the orchestrator that runs them) and Flyway (database migrations). Docker only arrives in 2013, and the authors were wary of Git. Read the principles, translate the examples.
- It is a thick enterprise manual, sometimes dry. The authors themselves suggest dipping into it rather than swallowing it whole. Do not read it in one go.
My advice: read chapter 5, the pipeline, and chapter 10, deploying and releasing, then skim the rest.
Odilon
Still relevant in 2026?
Yes, as long as you translate the tooling yourself. The principles have become the water the whole modern ecosystem swims in: the book won so thoroughly that we no longer cite it, its ideas passed into the tools.
| In the book | In 2026 |
|---|---|
| The deployment pipeline | A GitHub Actions or GitLab CI pipeline |
| Everything in version control | GitOps (the desired state of the infrastructure described in Git), with ArgoCD |
| Blue-green and canary | Kubernetes rolling updates (servers replaced one by one) and Argo Rollouts |
One fresh angle is added: when an AI generates and deploys code at full speed, a pipeline that catches defects early is no longer a comfort, it is the guardrail that stops speed from breaking everything.
Who is it for?
Read it if
- You deploy software and want to understand why behind your automatic deployment tools, not just configure them
- Your release day still looks like the red-eyed weekend anecdote
- You read The Phoenix Project or Accelerate and want the concrete recipes behind them
- You are starting a team and want to lay the right foundations from day one
Skip it if
- You want an up-to-date Kubernetes or GitHub Actions tutorial: the examples here are from 2010, translate them
- You want short and light: this is an enterprise doorstop you dip into
- Your team already practices continuous delivery by heart: you will only nod along
Going further
- The trio is complete with The Phoenix Project (the story) and Accelerate (the proof).
- For the 2026 version of these recipes, with Docker, FrankenPHP, CI to a container registry and rollback by tag, my deployment course walks through them hands-on.
- For the order to read these books in: my comparison of DevOps and engineering team books.
Comments (0)