How much of it actually goes away

The cost article ended on a caveat: $51,940 is what the current state costs, not a savings promise. The SOP article repeated it — savings are a separate number, smaller, and argued much more carefully. Neither one did the arguing.

Here it is. Getting from this process costs $37,800 a year to this change is worth something specific is where most business cases quietly turn into fiction, and they fail in a consistent way: the savings number gets derived from the total.

Savings attach to steps, not to processes

A process costs $37,800 a year. An automation touches four of its seven steps. The figure those four steps have anything to do with is not $37,800 — it's the share of the sixty minutes they occupy. Take a percentage of the total instead and you've produced a number that can't be checked, which is what "a 40% efficiency gain" is.

This is the whole reason the SOP carries per-step timings and not just a door-to-door duration. It's the costing test from that article, cashed in: with minutes attached to individual steps, the savings estimate becomes arithmetic over a subset of rows. Without them, it becomes a percentage someone chose.

Renewals, line by line

The modeled 24-person agency again — a fixture, not a client. Policy renewals run 90/month at 60 minutes each on a $35/hour blended rate, so the current state costs $37,800/year. Automate the intake, the data entry, the packet assembly, and the first reminder. Minutes per renewal:

Step	Now	After
Pull the expiring-policy list, confirm what's due	5	—
Re-key current policy data into the renewal application	12	—
Request updated exposure info from the client, then chase it	8	6
Assemble the packet and the quote comparison	14	—
Review the packet	8	8
Handle what changed — a new vehicle, a payroll figure, a coverage question	7	7
Send to the client and log the renewal	6	4
Total	60	25

Thirty-five minutes recovered × 1,080 renewals a year = 630 hours = $22,050/year, which is the gross figure the running-cost article starts from.

Two rows are doing the honest work there. The chase survives almost intact — automating the first request doesn't automate the client who ignores it, so eight minutes becomes six, not zero. And review and exception handling don't move at all, because they're the reason a person is still in the process.

The cap, and what it takes to beat it

Thirty-five of sixty is 58%, and our own drafting tool is not permitted to write that number. Its instructions cap any savings estimate at 50% of manual time unless the change eliminates the task outright, and tell it to round down. On renewals that yields 30 minutes, 540 hours, $18,900 — $3,150 below the table.

The cap isn't a claim about what automation can do. It's a claim about what an estimate is worth when nobody decomposed the process. Absent a step list, 58% and 40% are equally unfalsifiable, and the one that gets written down is whichever the person writing it needs to be true. The table above is the only thing that licenses going past the default, and it has to be a table someone walked through with the person who actually does the work.

The second rule matters as much and gets less attention: where there's no numeric basis, there's no number. If volumes and durations weren't captured for a process, the savings field stays empty and the finding is described in words. Not a range, not a placeholder, not an industry benchmark. It's the same discipline as [To be confirmed] in an SOP — a marked gap can be assigned to someone, while a plausible guess is indistinguishable from a captured fact a month later, and it's always the guess that gets built on.

What survives, every time

What stays	Why it stays
Review and approval	Someone accountable signs it — that's the function, not the overhead
Exceptions	The rule you wrote covers the standard case by construction. The rest still arrives
Chasing people	A reminder can be automated. The person ignoring it cannot
Judgment calls	The renewal where something genuinely changed needs a human, and it's the one that matters

A projection that trends to zero isn't aggressive, it's decorative — and it's usually a sign the estimate came off a total rather than a step list. If you can't name what's left, you haven't finished the analysis.

Recovered hours are not recovered dollars

This is the part most business cases skip, and it's the one an owner should press on.

630 hours a year is about 0.3 of a full-time person, spread across everyone who touches renewals. Nobody is laid off. No invoice gets smaller. $22,050 is the price of the hours recovered, and it turns into money in exactly three ways:

• Headcount you don't add as volume grows — the most common, and the easiest to verify a year later.
• Work redeployed onto something you'd otherwise have paid for, in-house or outside.
• Spend that actually stops — overtime, temp help, the contractor who covers renewal season.

If none of those is true, what you bought is capacity. Capacity is worth having, and it is not cash. The business case should say which of the three it's claiming, in a sentence, before the total appears. A number that doesn't name its mechanism is the one that gets quoted back to you in eighteen months.

Then subtract what the fix costs to run

The gross figure is still only one side. Against $22,050 sits the maintenance floor — build amortized over a realistic life, software, upkeep labor, breakage — which came to $5,110 a year at steady state, for a net of $16,940 from year two. That arithmetic is its own article, including the trap of counting residual manual work twice: if you priced the saving as sixty minutes dropping to twenty-five, the leftover work is already inside the twenty-five. Subtracting it again as a running cost makes good automations look bad.

So the defensible answer on a process costing $37,800 a year is roughly $16,900 a year from year two, contingent on the recovered capacity going somewhere nameable. About 45% of the current-state cost — not 100%, and not a number anyone would put in a headline.

That's one row. The harder problem is what happens when you have forty of them, all with their own caps and their own dependencies, and have to say which one gets built first. Most of what an assessment produces is this arithmetic run once per process and then defended in order.