Automation has a running cost. Price it before you build.

The last article put every candidate through the same final test: the annual value has to clear the maintenance floor with room to spare. It didn't say how high the floor is.

Nobody quotes you that number, because it isn't a quote. The build has a price and a proposal to put it on. Everything after launch is diffuse — a subscription here, an afternoon there, the Tuesday the renewal packets stop generating and someone spends half a day finding out why. It's real money. It just never lands on a single line, so it gets left out of the business case, and then it gets paid anyway.

Here's how to put it on the line.

Four items, one of which everyone forgets

Build. One-time, and the only figure most people have. It belongs in the running cost divided by the automation's realistic life — more on that below.

Software. The integration platform, the document generator, the extra seat tier the automation pushed you into. Small, predictable, and it climbs at renewal.

Upkeep labor. Hours, not dollars, until you price them. Two kinds: routine attention — working the exception queue, small rule edits when someone adds a field — and breakage, which arrives without notice when a vendor changes a form. Price these at the rate of whoever actually does the work, which is not the rate of the person whose time you're saving.

Residual manual work. The review, the exceptions, the odd one that needs a phone call. This is the item people forget, and the reason savings projections that go to zero are decoration.

One caution on that last item: count it once. If you priced the saving as "60 minutes drops to 25," the residual work is already in the 25. Subtracting it again as a running cost double-counts and makes good automations look bad. Pick one convention and hold it.

The same modeled agency, one automation, priced

Back to the 24-person insurance agency from the process-cost article — a modeled fixture, not a client. Its policy renewals run 90/month at 60 minutes each on a $35/hour blended rate: $37,800/year of current-state labor.

Automate the intake, the document assembly, and the reminder chain, and a renewal goes from 60 minutes to 25. A person still reviews every packet and still handles the ones where something changed. That's 35 minutes recovered × 1,080 renewals = 630 hours = $22,050/year gross.

Now the other side:

Running cost	Inputs	Annual
Build, amortized	$18,000 over a 3-year life	$6,000
Software	$220/month	$2,640
Routine upkeep	1.5 h/month × $95/h	$1,710
Breakage	2 events/year × 4 h × $95/h	$760
Residual manual work	already inside the 25 minutes	—
Steady-state cost (year 2+)	excludes build	$5,110

Which gives you the numbers worth saying out loud:

• Year one, cash: $22,050 saved against the $18,000 build plus $5,110 running. It loses about a thousand dollars.
• Year two onward: $16,940/year net.
• Payback: $18,000 ÷ $16,940 ≈ 13 months.
• Three-year net: $32,820.

That's a good automation. It is also nothing like "3x ROI in 90 days," and a controller can check every line of it. The $95/hour is deliberate — upkeep gets done by an internal technical owner or a retained builder, never by the $35/hour person whose afternoon you were buying back.

The floor is higher than small automations can clear

Run the same shape on a process worth $2,800/year. Recover a generous half and you've saved $1,400. Now spend it: eight hours a year of somebody's attention at $95 is $760, and a modest $45/month subscription is another $540. Net $100, before the build. You've cleared zero by a rounding error and added one more thing that can break, one more set of credentials, and one more thing somebody has to own.

That's not a rounding error, it's a verdict. The floor is why "annoying but rare" was a disqualifier and not just a low priority.

Two consequences worth being blunt about:

Ten small automations cost more than one large one. Each has its own vendor, its own credentials, its own quiet failure mode. The surface area is per-automation, not per-hour-saved. Consolidating three brittle scripts into one supported flow can reduce running cost while doing exactly the same work.

Eliminating the process beats automating it, every time. A deleted report has a running cost of zero and never needs an owner. It's still the highest-return move on most lists.

Amortize over the life it will actually have

Three years was a choice in that table, not a default. An automation lives until the ground under it moves — a system migration, a carrier changing its portal, a vendor sunsetting the API you built against.

So the amortization window is the time until the next likely change, and you usually know what that is. If the AMS contract is up for renegotiation in eighteen months, price the build over eighteen months, and watch a comfortable payback turn marginal. That's the same finding as the "it's about to change anyway" disqualifier, arriving with a number attached.

What drives the number up

Cost driver	Why it costs
Each additional integrated system	An independent source of breaking changes
UI automation or screen scraping	Breaks on cosmetic vendor changes, with no changelog and no warning
A vendor with no export or API	You're on the fragile path by construction
A high exception rate	The manual work you didn't remove, plus a queue somebody now watches
Rules set by regulation or carriers	They change on someone else's schedule
Custom code where configuration would do	More surface area, and it needs the person who wrote it
No named owner	Looks free. Costs the most.

That last row is the one that actually sinks projects. An automation without a name attached doesn't get cheaper; it decays quietly until the day it's wrong and nobody notices, which is worse than the manual process it replaced — the manual process had a person in it who would have caught that.

Which is the same mistake as "we just handle it in email," pointed the other direction. Unowned work isn't free work. It's unpriced work.

Price the floor once, carefully, for your own operation, and you can reuse it on every candidate after that. Most of a FIO roadmap is this arithmetic run twice per process — once on what it costs today, once on what it would cost to keep the fix running — and it's routinely the second number that shortens the list.