Skip to content
On this page 9

If deployment requires a hero, it isn't automated

A deploy that needs the right person, the right laptop or the right afternoon is a manual process with a script attached. Here is the difference.

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

#
Figure 1
A deployment path with review and an approval gate

The top lane shows a pull request, a plan posted as a comment, a review, and a merge. The merge feeds the lower lane, where the change is applied automatically to development, promoted to staging by a release, then held at an approval gate before it reaches production.

pull requestplanposted as a commentreviewcode ownersmergedevstagingapproval gatea person says yesprodsame artifact, carried forward — never rebuilt per environment
Change is computed and reviewed before anything is applied; promotion moves the reviewed artifact forward rather than rebuilding it. The only human action on the production path is an approval, and it is recorded.

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:

CheckWhat it catchesWhy it belongs before review
Formatting and lintingNoise that hides the real changeA reviewer should never spend attention on whitespace
Policy and security scanningInsecure defaults, exposed resourcesCheaper to find in seconds than in a review comment
Dependency and image scanningKnown vulnerabilities in what you are about to shipBlocks a class of problem that review cannot see
Repository-specific guardsHardcoded addresses, missing inputs, broken layoutEncodes the conventions that would otherwise be re-explained
Plan on an environment that does not exist yetWhether a brand-new environment can be created at allProves the code is complete, not just consistent
Cost estimate on the pull requestThe change that is correct and expensiveMakes 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.

Questions

What makes a deployment automated rather than scripted?

Automation means the process produces the same result regardless of who starts it, from a known state, with no undocumented steps in between. A script that requires local credentials, a particular machine or knowledge of which flag to pass is a manual process with a shortcut attached.

Should production deployments require human approval?

Usually yes, and that is not a contradiction. Automation removes the manual execution of steps. An approval gate keeps human judgment about timing and risk, which is the one part of the process worth keeping a person in. The gate approves; it does not perform.

Why post the plan on the pull request?

Because a reviewer cannot infer the effect of an infrastructure change from the diff alone. A plan shows what will actually be created, changed or destroyed, which moves review from reading intent to checking consequences, and it catches the destructive change that looked like a rename.

What is promotion by approval?

Building an artifact once, testing that exact artifact, and moving it between environments by granting approval rather than rebuilding it. Rebuilding per environment means production runs something that was never tested, however small the difference between the builds appears to be.

How do we know if we still have a hero problem?

Ask who deployed to production last month and whether anyone else could have. Then ask what happens if that person is on leave. If the answer involves waiting, or a video call to walk someone through it, the process is not automated yet.

This is what we build.

BuiltForProd deploys a production foundation into your own cloud accounts, hands over the repositories and the documentation, and, if you want it, keeps running it with your team. Tell us what you are running and what is coming next. The first call is 30 minutes, with an engineer who scopes engagements, not a salesperson.

The calendar invite and the video link go to this address. Prefer to write? Send a message instead.

Drift is a fact, not a failure

Infrastructure drift is not a sign of a broken team. It is information about what your environment needs. Detect it, triage it, and never auto-revert it.