
Engineers ask the same practical questions whenever the idea of a pre-flight checklist for deployments comes up: what goes on it, who reads it, does it slow things down, and is it not a bit childish? This FAQ answers them without ceremony. The short version: a deployment checklist is a brief card you read top to bottom, identically each time, ahead of a move you cannot easily take back. Everything below is about making that list useful rather than decorative.
What exactly is a pre-deploy checklist?
It is a written sequence of five to eight yes-or-no checks, run immediately before an action you cannot cheaply reverse. Releasing to production, running a destructive migration, changing DNS and altering permissions all qualify. It is not a project plan, a test suite or a review process. Those happen earlier. The card covers only the last few minutes before the button is pressed.
Why do experienced engineers still need one?
Because the errors that hurt are rarely complicated. Wrong environment, wrong version, backup not taken, nobody on call. Skilled people make these mistakes precisely because they are skilled: the steps feel automatic and attention wanders. A list interrupts autopilot. It does not insult expertise; it protects it.
What belongs on the card?
Start with the questions that catch the most common slips:
- Is this the version I tested, and is it the one about to ship?
- Am I pointed at the environment I intend to change?
- Is there a restore point, and do I know how to use it?
- Are alerts quiet, so I can see what my change does?
- Is someone able to approve a rollback and reachable now?
- Does anyone affected know this is happening?
Adapt these to your system. A team that handles payments will add a line about the billing window. A team with a large database will add one about migration timing. Keep every line answerable in a few seconds.
How long should the list be?
Brief enough to be read to the end. Most teams settle well on between five and eight lines. If your list needs scrolling, it is trying to do the job of a runbook or a review, and people will start ticking boxes without reading. When a new line is proposed, ask which existing line it should replace.
Does it slow the team down?
It adds a few minutes to risky releases and removes far more time from recovery work. Most teams find that after the first couple of weeks the card feels faster, because the vague worry about forgotten steps disappears. The comparison that matters is not “release with card versus release without card” but “release with card versus release followed by a bad evening”.
Who should read it, and when?
The person about to perform the action reads it, aloud if possible, immediately before starting. Reading it the day before is not the same thing, because circumstances change in between. For high-stakes changes, having a colleague listen is better still, but the card works for a lone engineer too.
What is the difference between this and a runbook?
A runbook describes how to do something, step by step. A launch card checks whether you are ready to start. One is a recipe; the other is the look around the kitchen before you turn on the heat. They complement each other, and confusing them is a common reason lists balloon beyond usefulness.
Can automation replace the card?
Partly. Anything that can be tested by a machine should be, and a pipeline that blocks a bad build is superior to a person remembering to check. But machines verify what they were told to verify. They will not notice that you are in the wrong account or that the person who can approve a rollback is on leave. Treat the card as the layer that covers context. A good card often includes a line such as “pipeline checks passed on this exact build”, which links the two.
How do we introduce it without eye-rolling?
Do not announce it as policy. Build the first version from your team’s own recent mishaps. Ask for the last two or three incidents and turn each into a line. People accept a list that reflects their real history. Pin it where the risky action happens: the top of the migration script, the release channel, the on-call handbook. Then use it yourself, visibly, for a few weeks.
What if we skip it under time pressure?
This is when it matters most, and when it is most tempting to drop. Establish a rule that the card can be shortened for low-risk work but not skipped for irreversible steps. If a release truly cannot afford three minutes of checking, it is probably too rushed to launch safely. Say so, and negotiate time instead of taking the risk quietly.
How do I use this to move up in my career?
Reliable launches are a reputation-builder. People who consistently release without drama get trusted with larger systems. If you are planning that next step, it is worth reading about the route from system administration and support into DevOps work, since the carefulness that makes an administrator good translates directly. Another useful overview is a broad roadmap of skills, projects and certificates for engineers, which pairs well with the habit described here.
Does this idea come from somewhere outside IT?
Yes, and that is part of its credibility. Aviation, medicine and construction have used short checklists for a very long time, usually after learning from avoidable accidents. The pattern is consistent: complex people doing familiar tasks under pressure benefit from a brief shared routine. Even informal communities converge on it. The CryptoBlockCoins site, a blog on cryptocurrency and blockchain with Coins, Tutorials and DailyLogs sections, is one example of a corner of the internet where irreversible actions are a daily topic and careful routines are valued.
What if two people disagree on an answer?
Then stop and settle it before launching. A card exists to surface exactly these moments. If one engineer believes the backup is current and another is unsure, the right response is thirty seconds of checking, not a majority vote. Treat any “I think so” as a “no” until someone has looked. This single rule changes the tone of release day more than any tooling, because it makes uncertainty something to resolve rather than something to hide.
Should every environment use the same card?
Use one card with a clear difference in weight. For a development sandbox, most lines are irrelevant and can be skipped. For staging, the target and version checks still matter. For production, run every line. Having one shared list prevents the drift where production rules live in a senior engineer’s head and nobody else can reproduce them.
Where do we keep it so that people use it?
Put it at the point of action. If releases go through a script, print the questions at the start and require a typed confirmation. If they go through a chat channel, pin the card. If they go through a ticket, make the lines part of the template. Wherever it lives, it should take one click or less to reach. A checklist stored three folders deep in a wiki is, for practical purposes, absent.
How often should we update the list?
After every incident or near miss, ask whether a line would have helped. If so, add it and retire something less useful. Every few months, read the card with fresh eyes and remove anything nobody can explain. A living card stays short and relevant. A frozen one becomes wallpaper.
Can you give one concrete example?
Certainly. A team is about to switch traffic to a new version of a service. The engineer reads the card. Version matches the tested build: yes. Environment is production, as intended: yes. Previous version still deployable: yes. Alerts quiet: no, one warning is firing. She pauses, investigates and finds an unrelated disk issue that would have clouded the release. The release proceeds an hour later, cleanly. The card did not fix anything; it simply made someone look.
Write your own version of that story after your next release. If a line caught something, you now have evidence. If none did, you still have a record of a routine release going to plan, which is worth having when somebody asks whether the few minutes were worth it.
Where should I start today?
Open a note and write six questions from the list above. Delete any that do not apply to your systems and add one based on your last unpleasant surprise. Use it before your next release. After three uses, review it and trim. That is the entire method, and trying it costs next to nothing.