Every automation pitch eventually hits the same question: “is it worth it?” The honest answer is that automation is sometimes a spectacular investment and sometimes an expensive hobby, and the difference is arithmetic, not vibes. This is the formula we run for every client engagement — the same one we’ll point to whenever this site claims something “pays for itself.”
The formula
Annual ROI = (hours saved/year × loaded hourly cost) + error cost eliminated − build cost − run cost
Four terms. The interesting part is what people systematically get wrong in each one, which is the rest of this article.
Term 1: Hours saved (where everyone starts, and everyone inflates)
The instinct is to time the task: “reconciling orders takes 40 minutes a day, so automation saves 200 hours a year!” — but automation rarely eliminates the whole task; it eliminates the mechanical portion. The honest count subtracts:
- The human review that remains — you still eyeball the output; that’s often half the original time
- The exception handling — the 10% of cases the automation can’t handle still need a human, plus the time to notice they’re exceptions
- The random breakage tax — every automation needs occasional fixing; we budget 15-30 min/month for simple flows, more for complex ones (see our self-hosting cost writeup for the real numbers on one case)
So the rule we use: estimate the full task time, then take 50-70% of it as actual savings. An honest “40 minutes a day” task saves 100-140 hours a year, not 200. Still very much worth building — just not fantasy-hours.
Term 2: Loaded hourly cost (where everyone undercounts)
The person doing the task costs more than their wage: taxes, benefits, software seat, office share, the overhead of employment. Multiply nominal wage by ~1.4 for a realistic loaded cost. A $28/hour admin is really a ~$40/hour cost.
The second undercount is subtler: whose time is it, really? If the founder does the task, the loaded cost isn’t their salary — it’s their opportunity cost, which for a founder is whatever their highest-value hour is worth (sales calls, product, strategy). Reclaiming five founder-hours a week at “founder rates” is often the entire business case for an automation, and it never shows up in a spreadsheet that uses salary math.
Term 3: Error cost eliminated (the term nobody counts, and the one that pays)
Here’s the term that surprises people: automations are often worth more for reliability than for time. Price the errors the manual process produces:
- The invoice that didn’t get sent → late cash, maybe a lost client
- The lead that sat in the inbox → the deal that went elsewhere
- The data-entry typo → the wrong shipment, the awkward apology
Run the numbers on your own failure log if you have one: errors per 100 manual executions × cost per error × reduction from automation (automation is very good at this: the error rate for “did the step happen” drops to near zero). For many businesses this term is bigger than the hours term — one missed invoice can outweigh a quarter of saved admin time.
There’s also the uncountable version: the 5-minute lead response that converts measurably better, the onboarding consistency that improves retention. We deliberately exclude these from formal ROI — call them upside, don’t bank them — but they’re real, and they’re why “the automation didn’t save obvious hours but clients stopped slipping through cracks” is a recurring pattern.
Term 4: Build and run cost (where the tool-tier decisions land)
Build cost: your hours × your rate. Our library of tutorials exists partly to push this number down — a documented pattern builds in 1-2 hours; the same thing figured out from scratch takes 4-6.
Run cost: tool tier + maintenance. Rough bands:
| Complexity | Tool cost/month | Maintenance |
|---|---|---|
| Simple (1 trigger, few steps) | $0-9 | ~15 min/mo |
| Medium (branching, multi-app) | $9-30 | ~30-60 min/mo |
| Self-hosted equivalent | $8-15 VPS | +20-30 min/mo ops |
And the failure mode worth naming: build cost amortization on dying tasks. If the task changes shape every three months (new systems, new process), the automation keeps needing rebuilds — the build term recurs, and ROI quietly rots. Rule: expect to rebuild any automation that touches a system you expect to replace within 18 months.
A worked example
Real client, real numbers, a small agency automating weekly client reporting (4 data sources → spreadsheet → email):
- Time: manual was ~3 hrs/week; automation eliminated 2 hrs (human still reviews) → 104 hrs/year
- Loaded cost: account manager at ~$42/hr loaded → $4,368
- Errors: ~1 bad/incomplete report a month reaching clients, ~$150 in trust-repair per incident, now ~zero → $1,800
- Build: 6 hrs × $60 (our rate) → −$360
- Run: Make Core + occasional maintenance → −$200
- Year-one ROI: ~$5,600 on a $360 build. Payback: under a month.
This is a typical case, not a showcase one — which is the actual lesson of the formula. The boring automations are the profitable ones.
The counter-example: when we told a client no
The formula earns its keep on the negative answers too, so here’s one of those. A two-partner architecture firm asked us to automate their project intake: assemble inquiry details, schedule the kickoff call, generate a proposal document from a template, route everything to the right partner. Sounded reasonable — until the frequency term. They take on roughly ten projects a year.
Run the terms honestly. Hours: intake involves maybe 35 minutes of genuinely mechanical work per project; at 50-70% capture that’s 20-25 minutes × 10 runs = under 4 hours a year. At the partners’ loaded cost ($95/hour), the hours term is ≈ $370/year. Error term: modest — an occasionally missed scheduling link, maybe $200/year of prevented friction. Build side: a genuinely branchy workflow (two partners, three intake sources, conditional proposal templates) — realistically 10-12 hours at our $60 rate plus ~$15/month of tooling and half an hour of monthly maintenance. Year-one cost: $1,100-1,300 against under $600 of value. The honest arithmetic: a loss, and not a close one.
We told them no — and what we did instead took forty minutes: a better intake form, a scheduling link, and a proposal template in their existing document tool. That captured maybe 70% of the value for 5% of the cost, because at ten runs a year the mechanical portion was never the expensive part; the judgment portion was, and judgment doesn’t automate.
Six months later they called back. A municipal framework contract had doubled their project volume to twenty-five a year, and a standardized intake process meant more of each project’s front end was automatable — closer to 45 minutes of mechanical work per project. Re-run the terms: 25 runs × 45 minutes × $95 ≈ $1,780/year in hours alone, plus a now-meaningful error term (a missed proposal on a municipal contract costs more than a missed scheduling link). We built it in a weekend, and it cleared breakeven inside seven months.
Two lessons, both worth the engagement. First: “no” from this formula usually means “not yet, at this volume” — the terms move with your business, and re-running the arithmetic is free. Second: notice which term flipped the answer. It wasn’t the hours saved per run; it was frequency. When you’re unsure about automating something rare-but-painful, don’t ask “is it worth it?” — ask “what would have to change for the answer to flip?” and then watch for that change.
The three objections, answered
“Our processes are too special to reduce to a formula.” At the level of content, sure — nobody else invoices quite like you. At the level of shape, there are about six patterns covering nearly everything a small business does repeatedly: move data between systems, notify someone, sequence steps over time, route by rules, roll up numbers, draft communication. The formula doesn’t care which one yours is; it only cares how often it runs and what an hour costs. The specialness lives in the judgment calls, which stay human regardless.
“By the time I’ve calculated the ROI, I could have built the thing.” The formula takes ten minutes on a whiteboard with rough estimates — it is not a business case for a bank. Precision isn’t the point; ordering is. Ten minutes of arithmetic filters out the two projects that would each have eaten a weekend and returned nothing, and those two weekends are what the formula actually buys you.
“What about the value we can’t measure?” The intangibles — the founder’s sanity, the client who renewed because nothing slipped, the lead answered in ninety seconds — are real, and we deliberately exclude them from the formal calculation as “upside, don’t bank it.” The discipline isn’t pretending they don’t exist; it’s not letting them carry a project the arithmetic can’t support. Automate what pays for itself, and let the unmeasurable benefits arrive as the bonus they are.
The three ways people fool themselves
- Counting hours nobody was actually spending. “This will save the sales team 10 hours a week” — but were they spending those hours, or were the leads just going unanswered? Answered-lead-revenue is a real ROI term but it must be modeled as revenue, not as hours.
- Ignoring maintenance forever. Every automation has a run cost. A spreadsheet that shows year-one ROI without a maintenance line is a spreadsheet about a theoretical business.
- Automating the impressive thing instead of the valuable thing. The AI research agent is cooler than the invoice reminder flow. The invoice flow is worth 10x more, every time. The formula is the discipline that keeps you building the boring winners.
When the formula says no
Respect a negative answer. Don’t automate: rare tasks (a few runs a year — the build never amortizes), shape-shifting tasks (rebuild cost recurs), and judgment-heavy tasks (the automation handles the 70%, and the 30% exceptions eat the savings). And be especially suspicious when the “hours saved” are your own tinkering hours — automating as a hobby is legitimate fun, just don’t file it under ROI.
Run the formula on three tasks this week. In our experience, one of the three will show a payback inside a month — and it’s almost never the one you’d have picked without the arithmetic.