A deployment is automated when the result does not depend on who starts it. Same input, same state, same outcome — from a laptop, a pipeline or a phone. By that definition a great deal of what teams call automation is not: a script exists, but it needs the right credentials, the right working directory, the right flags, and an engineer who knows which of the three prompts is safe to answer yes to. That is a manual process with better ergonomics. It works right up until the person holding it is unavailable, and then it does not work at all.
The tell is always the same. Ask a team who deploys to production. If the answer is a name, you have found the problem. If the answer is “the pipeline, after someone approves it”, you have found a process.
Three jobs, not one
#Most deployment pain comes from collapsing three distinct activities into a single step. Separating them is the whole technique.
Compute the change. Work out what would happen if this code were applied, and say so in detail. Nothing is modified. This step is safe to run on every commit, by anyone, as often as you like.
Review the change. A human reads the computed effect and decides whether it is what was intended. This is the only step that needs judgment, and it needs the output of the first step to be useful.
Apply the change. Execute exactly what was reviewed, from a known state, by an identity that exists for that purpose. No local credentials, no improvisation, no “I’ll just fix that one thing while I’m in here”.
When these three are one step, review happens after the fact, if at all — and the first time anyone learns that a change destroys a database is while it is destroying one.
What the path looks like
#The plan belongs on the pull request
#Reviewing an infrastructure diff without its plan is reviewing intent. The diff says a variable changed; the plan says eleven resources will be replaced, one of them stateful. Posting the computed plan as a comment on the pull request is a small piece of plumbing that changes the character of the review: the reviewer is no longer asked to simulate the tool in their head.
It also makes the destructive change visible at the only moment it is cheap to notice. “Replace” is a word that reads very differently in a plan than in a diff.
Ownership should be a file, not a habit
#If a directory holds the network, the identity model or the organization’s guardrails, the people who understand it should be required reviewers — expressed as a file in the repository, not as an expectation that someone will notice. Review requirements that depend on someone remembering to add a reviewer are load-bearing habits, and habits are the first thing to go in a busy week.
Gate production, don’t gate everything
#Development should apply on merge. Staging should be a deliberate act, such as cutting a release. Production should require an approval from someone who is allowed to give it, recorded with a name and a time.
This is not a compromise on automation. It is the point of it: the machine does the work, the person decides the timing. What a gate must not become is a place where someone performs steps. If an approver has to do anything other than read and click, you have rebuilt the hero problem inside a nicer interface.
Promotion by approval, not by rebuild
#The same principle applies one layer up, to what reaches production.
Rebuilding an artifact for each environment feels tidy and quietly defeats the testing you just did. A rebuild from the same commit is not guaranteed to be the same artifact: base images move, transitive dependencies resolve differently, a registry serves a newer tag. What runs in production is then something that has never been tested, and the difference is invisible until it matters.
Build once. Test that build. Promote that artifact forward by approval. The Web App Blueprint follows this: one immutable image built on merge, deployed automatically to development, promoted to staging by cutting a release, and released to production behind a manual approval with required reviewers. Production does not receive a new build. It receives permission for the build that already passed.
The guardrails that make review meaningful
#A review gate only helps if the thing being reviewed is valid. Automated checks belong before human attention, not after it. The ones that pay for themselves:
| Check | What it catches | Why it belongs before review |
|---|---|---|
| Formatting and linting | Noise that hides the real change | A reviewer should never spend attention on whitespace |
| Policy and security scanning | Insecure defaults, exposed resources | Cheaper to find in seconds than in a review comment |
| Dependency and image scanning | Known vulnerabilities in what you are about to ship | Blocks a class of problem that review cannot see |
| Repository-specific guards | Hardcoded addresses, missing inputs, broken layout | Encodes the conventions that would otherwise be re-explained |
| Plan on an environment that does not exist yet | Whether a brand-new environment can be created at all | Proves the code is complete, not just consistent |
| Cost estimate on the pull request | The change that is correct and expensive | Makes cost a review concern rather than a monthly surprise |
The AWS Enterprise Baseline ships six such guard scripts alongside formatting, policy and vulnerability scanning, with every pipeline action pinned by commit hash so that a supply-chain change upstream cannot quietly alter what runs. Applies proceed across all fifteen accounts in dependency order, and production is gated by a repository environment with required reviewers. Those specifics describe the AWS edition; the property — automated, in the sense that provisioning and deployment repeat without heroics — is part of the Standard in every edition.
Where teams stall
#Three patterns account for most stalled automation efforts:
The pipeline exists but people bypass it. Usually because it is slow or flaky. A pipeline that takes forty minutes will be bypassed during an incident, and the bypass will become normal. Fix the speed before adding the policy.
Only some environments are covered. Production is automated, development is manual, and they drift apart until “it works in staging” stops meaning anything. Cover them with the same code path and different inputs.
The automation has an owner instead of a team. One person wrote it, one person maintains it, and everyone else treats it as weather. If the deploy path is not reviewed like application code, it decays like uncared-for application code.
The one question
#At your next retrospective, ask: who deployed to production last, and could anyone else have done it the same way?
If the honest answer needs a name, you know what to work on. That is the same question we ask during a BuiltForProd Assessment, and it is usually the one that produces the longest silence.