A factory runs a machine three times before it is accepted. First on its own floor, with the customer watching. Then on the customer’s floor, after installation. Then under production load, with real material going through. Three acceptance stages, three sign-offs, and a defined meaning for a failure at each one.
Software runs the same three stages and calls the middle one user acceptance testing.
Both industries faced one problem — how do you find out a thing is wrong while it is still cheap to correct — and both answered it by staging acceptance. The vocabulary is local. The structure is not.
Most of what a software organisation runs above the code is management, and it is usually treated as the soft layer sitting on top of the real work. Waterfall is a management scheme. Scrum is a management scheme. Formal project management, quality control, release governance, capacity planning — each is an instance of a general management practice, with the terms remapped to fit a vertical whose units are commits and screens rather than drawings and cabinets. The remapping tracks one number: the cost of one change.
The names are local; the structures are not
Staged acceptance, under three names
Construction stages it as pre-commissioning checks, commissioning under load, then practical completion. Software stages it as a staging environment, user acceptance, then a monitored release.
The structure is the same in all three: the thing is exercised in a controlled setting, then in the real one, then under real load, and the responsibility for defects moves one step at each transition. Each of those industries will tell you its version is specific to it.
The same holds for change control, for design authority — the separation between whoever designs and whoever builds — and for who owns a defect after handover. Four structures, three sets of names, each taught as its own.
| THE STRUCTURE | MANUFACTURING CALLS IT | CONSTRUCTION CALLS IT | SOFTWARE CALLS IT |
|---|---|---|---|
| Staged acceptance | A test at the vendor’s plant, a repeat after installation, then a run under production load. | Pre-commissioning checks, commissioning under load, then practical completion. | A staging environment, user acceptance, then a monitored release. |
| Change control | An engineering change order against a released design, with every affected unit identified. | A variation order, priced and approved before work proceeds, and the drawing reissued. | A branch, a review, a merge. The history is the record. |
| Design authority | The design office owns the specification; the line builds to it. | The engineering office calculates and stamps; the contractor builds. | The architect owns the boundaries; whoever executes builds inside them. |
| Who owns a defect after handover | A warranty on the delivered unit, then a service agreement. | The defects-liability period; retention is held until it expires. | An intensive support window after release, then ordinary maintenance. |
Local training hides the transfer
You do not learn empirical process control and then learn that Scrum is its software instantiation. You learn Scrum. A construction manager does not learn change control and then learn that the variation-order process is its instantiation — they learn the variation-order process, along with the forms. Every vertical teaches its own dialect as though it were the language, and certifies people in the dialect.
The cost: when your vertical has a gap, little in your training tells you another vertical has already closed it.
The terms change because the price does
One label, two prices
Take one change and apply it to every place it appears.
On a control-systems project, that means changing one wire’s label in every cabinet: sixty identical cabinets across four buildings. The marker is a sleeve the conductor passes through, so each cabinet is opened under a permit, the circuit isolated, the conductor lifted from its terminal to take the new sleeve and terminated again, the loop re-tested, and every drawing that carries the old number revised. That is a crew, a shutdown and a week. The cheaper route, a clip-on marker over the old one, still means reaching into the wiring, and it leaves two label formats in one cabinet and a deviation someone has to accept.
In software it means changing a label on every screen. One edit, a test run, a deploy. That is a commit, and if it is wrong you revert it.
The same sentence describes both jobs. The price is what separates them.
Every apparatus is sized to that price
Where a change costs a shutdown, change control comes with a design freeze, a review board and an approval chain — because the review is cheap relative to the change it prevents. Where a change costs an hour, that same apparatus costs more than the mistakes it catches, and what you get instead is version control, automated regression and rollback.
Both are the correct answer to their own price. The rigour is equal; what differs is where it is spent.
| THE VERTICAL | WHAT ONE CHANGE COSTS, APPLIED EVERYWHERE IT APPEARS | THE APPARATUS THAT PRICE JUSTIFIES |
|---|---|---|
| Software | A commit and a deploy. If it is wrong, you revert it. | Version control, automated regression, staged rollback. Correcting costs less than preventing, so the apparatus is built for correcting. |
| Manufacturing | A rework order reaching every unit already built, and the ones already shipped. | Change orders against a released design, revision control on the parts list, a freeze before the production run. |
| Construction and site work | A crew, a shutdown and a week, with the drawing reissued afterwards. | Variation orders, a design freeze, an approval chain. Review costs little against the change it prevents. |
| Certified systems | Recertification before the thing is allowed to operate again. | Configuration management, formal impact analysis, and re-approval by the authority that issued the certificate. |
Ordered by price, cheapest first. The order is the claim; the spacing is not measured.
The same mechanism runs on the time axis, which an earlier post in this series traced: development methods encode the cost of their era, and when that cost collapses the method has to move or it survives as ritual. Across verticals the mechanism runs sideways: at a single moment in history, one structure wears whatever apparatus each vertical’s price can justify.
Take the structure, price the apparatus
Read the vertical where your problem is expensive
A vertical’s strongest management practice sits on its most expensive failure. That is the search rule.
Construction pays for a design error with something already built, and sometimes with lives. So construction has the strongest design authority — a hard separation between the party that designs and the party that builds — an inspector with the authority to stop work, and a signature that carries liability for years after handover.
Manufacturing pays for a defect found after shipment with a return, a travelling engineer, and occasionally a recall across a production run. So manufacturing has the most developed acceptance staging, and the most careful definition of what each stage is entitled to conclude.
Aviation pays for an omitted step with an accident. So aviation has the most developed procedural completeness — the checklist, and the discipline of enumerating cases rather than trusting recall.
The transfer runs in both directions. Software pays most for uncontrolled change over time — a system nobody can safely modify — so software produced the most developed answer to that: version control, automated regression, staged rollback, continuous integration. Manufacturing engineering teams are taking those up now, as are design offices whose drawings live in a shared model rather than on paper. They are taking them up for the reason above: their own price for an uncontrolled change went up.
Map the price before you take the apparatus
A transfer fails in one predictable way. The structure arrives with its apparatus attached, and that apparatus was priced for somebody else’s cost of one change.
Import a construction-style variation approval chain into a software team and you have priced a commit like a site shutdown: a review chain around a change that could have been reverted in a minute. Import ship it and correct it in production into a company that builds physical machines and you have priced a recall like a commit.
One question decides it: does the failure this apparatus prevents cost me what it costs them? If it does, take the apparatus as it stands. If it does not, take the structure and build your own apparatus at your own price.
The engineering-office argument applied this rule. It took construction’s design authority and the stamp, because the failure those prevent — a design error discovered after the thing is built — is expensive in software too. It did not take the permitting timeline, the drawing revision protocol, or any of the forms. Those are priced for a site.
A solution is managed into existence
Below a certain line the work is genuinely technical, and the terms there are technical for a reason: a memory model, a query plan, a wire gauge, a load path. Above that line, every question is a management question. What gets built, in what order, against whose definition, verified by whom, accepted on what evidence, changed through what process, owned by whom afterwards.
Those questions have the same shape whether the artifact is a building, a machine or a product. A company that answers them badly does not end up with a worse version of the thing. It usually does not end up with the thing.
The technical skill decides whether something can be built. The management above it decides whether it gets built, and whether what arrives is what anyone wanted.
Underneath all of it is a short sequence: read the reality as it is, name the goals the solution has to reach, then wire a solution that reaches them without contradicting anything already true in the system it lands in. Every vertical runs that sequence. Each has its own word for each step, and its own price attached to getting the third one wrong.
Building is one stage of managing a solution into existence, which is why most of what we publish sits above the code.
The last management practice your team adopted — which vertical’s price was it built for?