Let us be honest about deployments. Most of them are boring, and that is exactly why they bite us. After a few hundred uneventful releases, it is easy to start treating the next one as routine, skim the checks and push the button while a message notification pulls your eyes sideways. Then one release goes wrong, in a way that would have been obvious if you had looked for ten seconds. This post shares eight items for a pre-deploy checklist, the kind you run right before a change that is hard to roll back, such as a database migration or a configuration push to production.
A quick framing before the list. These eight items are for the launch moment only. They are not a project plan, a code review guide or a full release process. Think of them as the last pause between ready and committed, the same pause pilots take before they taxi onto a runway. Same list, same order, every time.
1. The migration has been read by a second person
Schema changes are the classic point of no return. Dropping a column, renaming a table or adding a constraint on a large dataset can lock things up or destroy data in ways that no code rollback repairs. Before deploy, confirm that someone other than the author has actually read the migration, not just glanced at the pull request summary. The question to ask is what this does to existing rows, and how long it will take on production-sized data.
A concrete example: a team adds a non-null column with a default to a busy table. On a small test database it finishes instantly. On the real table, it holds a lock long enough for requests to queue and time out. A reviewer who thought about table size would have flagged it.
2. Rollback is ready, and has been tested at least once
Saying we can just roll back is easy. Having a rollback that works is a different thing. Confirm that the previous version is still available to redeploy, that the database change is either reversible or compatible with the old code, and that somebody knows the exact command or button. If the migration is not reversible, say so out loud and decide whether to proceed.
3. Alerts are quiet before you start
This one is easy to forget. If your monitoring is already noisy or showing something unusual, you will not be able to tell whether your deploy made it worse. Take a quick look at dashboards and the alert list. Everything should be calm or the known issues should be understood. Starting a risky change on top of an unexplained wobble is a recipe for confusion.
4. An owner is on call and reachable
Every deployment needs a named person who will notice trouble and has the authority to act. Not a team in general, an actual individual. Check that they are at their desk or on the rota, that their phone is on, and that they know a deploy is happening. Friday evening releases without a named owner are a well-known source of weekend incidents.
5. Configuration and secrets are what you think they are
Many production incidents come down to a setting that differs between environments. Before you deploy, compare the environment variables, feature flags and credentials the new version expects against what production actually has. A missing variable often does not fail at build time. It fails on the first real request.
6. Capacity and traffic look normal
Releasing during a traffic spike makes everything harder to interpret. Check that load is within the usual range and that no big event, campaign or batch job is about to start. If you are thinking about how your platform copes with surges, the discussion of handling very large volumes of web traffic on modern cloud infrastructure gives useful context for why timing and headroom matter.
7. The change is small enough to explain in one sentence
A release you cannot summarise in a single line is probably carrying too much. Large releases hide problems, because when something breaks you cannot tell which of fifteen changes caused it. Where possible, split the release. If it genuinely must go together, make sure at least two people understand all its parts. A well-scoped change also connects back to clear requirements, which the piece on putting together engineering requirements for a web project covers in depth.
8. You know what success looks like and when you will check
The final item is about the minutes after the deploy. Agree beforehand on two or three signals that will show you the release is healthy: error rates holding steady, a key page loading, a test transaction completing. Then agree when you will look at them. Many teams declare victory the moment the pipeline goes green, and discover an hour later that real users are seeing errors the pipeline never tested.
It also helps to write down who will make the call if one of those signals looks wrong. A rollback decision made by committee in the middle of a degraded service tends to take far longer than one made by a single person who was named ahead of time. Put that name beside item eight, so there is no debate while users are waiting.
One more practical detail: record the time the deploy started. When someone later asks whether a spike in errors lined up with the release, a timestamp turns a long argument into a quick look at a graph. It costs five seconds and settles more disagreements than any amount of memory.
Bonus: what to leave off the list
Resist the urge to add more items. Every extra line makes the list slower, and slower lists get skipped. If a check belongs earlier in the process, such as code review, automated tests or security scanning, put it there. The pre-deploy list is for conditions that can only be confirmed at the last moment. A good test: if the item could have been checked yesterday without losing meaning, it does not belong here.
How to make the list stick
A checklist nobody uses is a document. A few habits keep it alive.
- Read it aloud. Whether in chat or on a call, say each item and wait for a yes. Silence is not an answer.
- Keep it where the deploy happens. Pin it in the release channel or put it in the pull request template, so it appears at the moment of need.
- Edit it after every surprise. Whenever a problem gets past you, work out which question was missing and write it in. When a line never matters, retire it.
- Use it for small releases, too. A habit only used for big days will not be there on an ordinary Tuesday.
A small outside perspective
Sometimes it helps to see the same instinct in a different field. The CryptoBlockCoins site publishes crypto and blockchain writing split into coin pages, tutorials and daily logs, and its whole subject revolves around actions that cannot be reversed after they are confirmed. Engineers who read there will recognise the logic immediately: when the undo button does not exist, the checklist becomes your undo button, moved to before the action instead of after it.
Putting the eight to work
If eight feels like a lot, start with three: rollback ready, alerts quiet, owner on call. Those cover a surprising share of painful releases. Add the others over time as you see which gaps matter in your own system. Try it on your next deploy and see how it feels. The first time, it may seem like a ceremony. By the fifth time, you will probably catch something that would have cost you an evening.
The goal is not perfection. Systems will still surprise you. The goal is to check that any surprises are the worthwhile kind, rather than the kind that come from a skipped step you already knew about. Eight lines, same order, spoken aloud, and a calmer release every time.

