Eight Habits That Make Every Release Easy to Reverse

Eight Habits That Make Every Release Easy to Reverse

Let’s be honest: nobody enjoys the moment right after a release when a dashboard starts to wobble and the team chat goes quiet. The good news is that much of that dread comes from one thing, which is not being able to undo the change. If you can step back in a minute or two, a bad release is an irritation. If you cannot, it is an incident. Here are eight habits that make reversible releases the default for your team, explained in a friendly way and in the order I would adopt them.

1. Put new behaviour behind a feature flag

A feature flag is simply a switch in your configuration that decides whether a piece of code runs. You ship the code dark, turn it on for a few people, and turn it off again if something looks wrong. The deployment and the exposure become two separate steps, which is a huge relief. Rolling back no longer means redeploying; it means flipping a switch.

One warning: flags are cheap to add and expensive to forget. Name a person who looks after each flag, set a date after which it must go, and delete it once the feature has settled. Stale flags turn into a tangle that makes the code harder to reason about.

2. Keep the previous version ready to return to

It sounds obvious, yet plenty of teams discover during an outage that the last good build was never kept, or that restoring it takes an hour of manual steps. Keep the previous artefact, keep its configuration, and rehearse the return. A rollback you have never practised is a rumour, not a plan.

3. Release to a slice of traffic first

Sending a change to a small share of users, then widening it as confidence grows, turns the whole audience into a gradual test rather than an all-or-nothing gamble. If problems show up, only a sliver of people ever saw them, and pulling back is quick. Combine this with the flag habit and you gain very fine control over who sees what.

4. Split risky database changes into undoable steps

Databases are where reversibility is hardest, because data written under a new structure cannot always be turned back. The usual cure is to change in small, compatible stages. First add the new column alongside the old. Then write to both. Then move readers across. Only at the very end do you remove the old structure. Each stage can be paused or reversed, and the one irreversible step, the removal, comes last and only after real evidence that nothing needs the old path.

5. Separate “deploy” from “release”

Deploying means the code is on the servers. Releasing means users can reach it. When the two are welded together, every deployment is a public event. When they are separate, you can deploy at a calm hour, verify quietly and release when you are ready. This small piece of vocabulary changes how teams plan their days.

6. Make the rollback a button, not a project

If returning to the previous version requires a senior engineer, three terminals and a prayer, people will hesitate to use it, and hesitation is what lets a small fault grow. Automate the way back until it is as simple as the way forward. The more boring the rollback, the more likely someone will use it early.

Also decide in advance who is allowed to press it, and make sure they know they will not be blamed for doing so. A rollback that is treated as an admission of failure will be avoided, while one treated as routine housekeeping will be used at the first sign of trouble.

7. Tag your decisions as reversible or not

This one is about habits of thought rather than tooling. When a team plans a change, add one line to the plan: “Reversible: yes or no, and how.” A change you can retract in minutes can proceed with a light review. A change that cannot be retracted, such as deleting data, rotating a key that other systems rely on, or retiring a service, deserves a slower, more careful path. Tagging forces the conversation to happen before the pressure arrives.

For a sense of how requirements and early decisions shape what is easy to change later, the article on writing web project requirements that survive contact with reality is a useful read, since many irreversible choices are made quietly at that stage.

8. Watch the effects, then decide whether to stay

A reversible release is only useful if you notice when it needs reversing. Decide ahead of time what you will look at after a change and what would make you pull back. Keep the list short and concrete. Then give the change a defined observation window before declaring it done. Without that window, you have the escape hatch but no reason to open it.

Infrastructure matters here too. A setup that can scale without drama gives you headroom to experiment, and the piece on how modern cloud infrastructure absorbs surges of visitors explains why capacity planning and reversibility reinforce each other.

Objections you will hear, and fair answers

“This slows us down.” It slows the first few releases a little, because you are building the safety net. After that, releases get faster, because nobody is waiting for a long approval meeting to bless a change that can be withdrawn in a minute.

“Flags make the code messy.” They can, which is why expiry dates matter. Treat a flag as scaffolding that comes down when the building is finished, not as a permanent fixture.

“Some things simply cannot be rolled back.” True, and that is the whole reason for habit seven. Deleting records, sending emails to customers and changing public addresses are all one-way. For those, the answer is not to roll back but to prepare: take a copy first, stage the change, test on a copy of the data and ask a second person to read the plan.

“Our system is too old for this.” Older systems often benefit most. You may not be able to add flags everywhere, but you can almost always keep the previous build, automate the return and split a database change into stages. Start there, and do not wait for a rewrite.

Bonus: where to learn the craft

If you want structured help, look for people who teach delivery practice as well as tools. DevOpsSchool Netherlands is based in Amsterdam and offers consulting and training across DevOps, SRE and cloud delivery, which makes it a natural place to look for guidance on staged releases and rollbacks, particularly if your team works across several time zones and cultures and needs a shared approach.

A day in the life of a reversible release

To make this concrete, picture a Tuesday morning. A developer merges a change to the checkout page. It deploys quietly to the servers, with the new code hidden behind a flag. A teammate turns the flag on for internal staff and clicks through the page. Nothing odd. By lunchtime, the flag is enabled for a small share of real visitors, and someone keeps an eye on errors and orders. In the afternoon the share grows. If anything had gone wrong, the response would have been a single switch, not a war room. By the evening the feature is live for everybody, and the flag is scheduled for removal next week.

Putting the eight habits in order

You do not need to adopt everything at once. A sensible sequence goes like this. Start with keeping the previous version ready and practising the return, since that costs the least. Add the deploy-versus-release split next. Then introduce flags, with owners and expiry dates. After that, move to gradual traffic, then tackle the staged database pattern, and finally introduce decision tagging and observation windows as team habits. Each step makes the next one easier, and each is itself a small, reversible experiment.

If you are curious how these habits fit within a broader engineering outlook, the overview of our practical approach to cloud, DevOps and platform work gives a sense of the surrounding context.

A final thought

The point of all eight habits is not to make releases timid. It is to make them cheap to attempt. When the cost of being wrong drops, teams ship more often, learn faster and spend far less energy on dread. Keep a short list of truly permanent actions, treat them with respect and move everything else onto the undoable path. Your future self, awake at three in the morning, will thank you.