Automation ROI: Run the Math Before You Build

By Lazar Milicevic · Published June 18, 2026 · 11 min read

You found a workflow that screams "automate me." Maybe it's the weekly invoice chase, the lead enrichment dance, or the support triage that eats your Monday. Before you open n8n, write a single line of Python, or pay anyone to build it — sit down for ten minutes and run the numbers. Most automations that look like obvious wins fall apart on a napkin once you include maintenance.

The one-line formula that filters 80% of bad ideas

Here's the whole business case:

Annual ROI = (Hours saved/year × Loaded hourly cost) − (Build cost + Annual run cost + Annual maintenance cost)

Four inputs. That's it. The problem isn't the formula — it's that most people lie to themselves about three of the four numbers. They inflate hours saved, ignore loaded cost, and pretend maintenance is zero.

Let's go through each input honestly, then walk a real example, then talk about when the math says "don't build this."

Hours saved: count the task, not the calendar

The most common mistake: "this task takes me half a day." No it doesn't. It takes you 22 minutes of actual work spread across half a day of context switches.

To get an honest number, measure the task itself for a week. Use a timer. Write it down. Then multiply by frequency.

Hours saved/year = (Minutes per run / 60) × Runs per year × Adoption rate

Two things people forget:

Adoption rate. If you build a tool your team uses 70% of the time and falls back to the old way 30% of the time, your savings drop by 30%. For solo founders this is usually 100%. For team automations, assume 70-85% in year one unless you have strong process discipline.

The 80% rule. Most automations handle the happy path and kick edge cases to a human. If 15% of cases still need manual review, you're not saving 100% of the time — you're saving roughly 85% minus whatever the review itself takes.

A worked version:

minutes_per_run = 12        # measured, not guessed
runs_per_year = 1_500       # ~30 per week
automation_coverage = 0.85  # 15% kicked to human review
adoption_rate = 1.0         # solo founder, no team friction

hours_saved = (minutes_per_run / 60) * runs_per_year * automation_coverage * adoption_rate
# = 0.2 * 1500 * 0.85 * 1.0 = 255 hours/year

255 hours is a believable number. "I'll save 20 hours a week" almost never is.

Loaded hourly cost: your time is more expensive than you think

Loaded cost means total cost of an hour of work, not the take-home wage. For an employee, it's salary plus payroll taxes plus benefits plus the share of overhead they consume (software seats, office, equipment, management time).

A reasonable rule of thumb for a US/EU full-time employee: loaded cost ≈ 1.25× to 1.4× base salary. For a contractor or yourself as a founder, loaded cost is the higher of:

1. What you'd pay someone else to do this work, or
2. What you could earn doing your highest-value billable work in that same hour (opportunity cost).

If you're a founder who charges $150/hr for client work, every hour you spend reconciling invoices costs you $150 in foregone revenue — even though no money leaves your bank account. That's the real number to plug in.

Pick one number and write it down. Don't use the highest one to justify the build, then complain you can't afford it.

Build cost: be honest about all-in time

Build cost includes:

• Discovery and spec time (often skipped — usually 10-20% of build)
• Actual build time
• Testing on real data
• Documentation so future-you understands it
• Onboarding anyone else who uses it

If you're building it yourself, multiply your build hours by your loaded cost. If you're hiring it out, use the quoted price plus your own time on discovery and review (usually 15-25% of the quote).

A small but real automation — say, "watch inbox, classify support emails, draft replies in Gmail, send the easy ones, queue the hard ones for review" — is realistically 15-40 hours of senior build time, including the parts nobody quotes for: handling auth refresh, retry logic, a simple admin UI to see what got sent, and a kill switch.

If someone quotes you 4 hours for that, they're quoting the demo, not the system.

Run cost: cheap, but not free

Run cost is what it takes to keep the thing running for a year. Typical lines:

• LLM API calls (per token, varies by model and provider — check the current pricing page)
• Workflow platform (n8n self-hosted, Make, Zapier, custom)
• Hosting (a small VPS, a managed function platform)
• Vector DB or storage if you have RAG
• Monitoring / error alerting

For most SMB automations, run cost lands somewhere between negligible and a few hundred dollars a month. The trap isn't the absolute number — it's forgetting to estimate it before you build with the most expensive model on day one. Always sanity-check: cost-per-run × runs-per-month. If a single workflow run costs $0.40 in LLM tokens and runs 3,000 times a month, that's $1,200/month. Different math.

cost_per_run_usd = 0.08      # LLM + storage + compute
runs_per_year = 1_500
platform_per_year = 240       # self-hosted n8n on a small VPS
monitoring_per_year = 120

annual_run_cost = (cost_per_run_usd * runs_per_year) + platform_per_year + monitoring_per_year
# = 120 + 240 + 120 = $480/year

Maintenance: the line nobody puts on the napkin

This is the one that kills bad ROI estimates. Every automation you build is now something you own. APIs deprecate. Gmail changes scopes. The vendor adds CAPTCHAs. A model gets retired and the new version handles your prompt differently. Your business logic changes and the automation needs to follow.

A defensible maintenance estimate for a small-but-real production automation:

Multiply by loaded hourly cost. For a medium automation maintained by a senior engineer, that's $1,500–$3,500/year just to keep the lights on. If you ignore this line, your ROI looks fantastic on day one and you wonder why you're losing money by month nine.

A separate rule of thumb: if a workflow breaks and nobody notices for two weeks, you don't have an automation — you have a liability. Budget for monitoring, or budget for the cleanup when it silently fails.

Putting it together: a real example

A solopreneur runs a small agency. She spends ~30 minutes per new lead doing enrichment (LinkedIn lookup, company size, recent news, drafting a personalized first-touch email). She gets about 8 qualified leads a week, year-round.

Inputs, measured honestly:

minutes_per_run         = 30
runs_per_year           = 8 × 50 = 400
automation_coverage     = 0.80  (top 20% need manual touch)
loaded_hourly_cost      = 120   (her own opportunity cost)

build_hours             = 25
build_hourly            = 120
annual_run_cost         = 600   (LLM + scraping API + platform)
annual_maintenance_hrs  = 20

Math:

hours_saved = (30/60) * 400 * 0.80          # = 160 hours
gross_value = hours_saved * 120             # = $19,200

build_cost      = 25 * 120                  # = $3,000
run_cost        = 600
maintenance     = 20 * 120                  # = $2,400

year_1_net  = gross_value - build_cost - run_cost - maintenance
            # = 19,200 - 3,000 - 600 - 2,400 = $13,200
year_2_net  = gross_value - run_cost - maintenance
            # = 19,200 - 600 - 2,400 = $16,200

payback_months = build_cost / ((gross_value - run_cost - maintenance) / 12)
              # ≈ 2.2 months

That's a build. Clear payback, room for the estimates to be wrong by 30% and still positive, and the maintenance line is honest.

Now flip it. Same person, but the task is "draft monthly client invoices" — 15 minutes each, 6 clients, once a month. That's 72 invoices a year.

hours_saved = (15/60) * 72 * 0.90  # = 16.2 hours
gross_value = 16.2 * 120           # = $1,944

# Even cheap: build 15h × $120 + $200 run + 8h maintenance × $120
total_cost = (15*120) + 200 + (8*120)  # = $2,960

Year one is negative. Year two breaks even. The honest answer here is: don't automate, use a $20/month invoicing tool with templates, or batch all six invoices into one 30-minute session. The math told you before you wasted a weekend.

When the math says "don't build this"

Patterns where automation almost never pays back:

• Low frequency, low duration. Anything under ~50 hours/year of total task time rarely beats build + maintenance for a custom system.
• Highly variable inputs. If every instance of the task is structurally different, you're building a janky agent that needs constant supervision. The maintenance line eats you.
• The task is already a symptom. If the work exists because of a broken upstream process, fix the upstream process. Don't automate the cleanup forever.
• You don't actually do the task today. Automating a task you "should" be doing but aren't is just a more expensive way to discover you didn't need it.
• A SaaS already solves it for $30/month. Build vs. buy is a real question. If a category-leader tool covers 80% of your need, the math almost always favors buying.

The right call is sometimes "this is interesting but not worth building." Saying that out loud, early, is the most valuable thing an engineer can do for a client.

A napkin checklist you can use today

Before you build any automation, fill this out:

automation: "Lead enrichment + first-touch draft"

hours_saved_per_year:
  minutes_per_run: 30          # measured for a week
  runs_per_year: 400
  coverage: 0.80
  adoption: 1.0
  total: 160                   # auto-calc

loaded_hourly_cost: 120        # opportunity cost or fully loaded FTE

build_cost:
  hours: 25
  hourly: 120
  total: 3000

annual_run_cost: 600           # LLM + APIs + platform

annual_maintenance:
  hours: 20                    # be honest
  hourly: 120
  total: 2400

verdict:
  year_1_net: 13200
  year_2_net: 16200
  payback_months: 2.2
  decision: BUILD              # or DON'T BUILD, or BUY INSTEAD

If the verdict line says "BUILD" with payback under 6 months and year-1 net comfortably positive after you stress-test the inputs by ±30%, go. Otherwise, stop.

How BizFlowAI approaches this

Every BizFlowAI discovery call starts with this exact math, on a shared doc, in front of the client. We fill in the four inputs together — hours measured, not guessed; loaded cost agreed on up front; build cost based on what the system actually needs, not a demo; and a maintenance line that doesn't pretend to be zero. Sometimes the verdict line says BUILD and we scope the work. Sometimes it says BUY INSTEAD and we point at a $30/month tool that does 80% of it. And sometimes it says DON'T BUILD, and the call ends there.

That last outcome is the point of the call. A senior engineer telling you not to build something is worth more than a quote for something that won't pay back. If the numbers don't work, we'd rather you keep your money and come back when there's a problem worth solving.

Frequently asked questions

How do I calculate the ROI of a workflow automation?

Use this formula: Annual ROI = (Hours saved/year × Loaded hourly cost) − (Build cost + Annual run cost + Annual maintenance cost). Hours saved should be measured with a timer, not estimated, and multiplied by frequency, automation coverage (typically 80-85%), and adoption rate. Loaded hourly cost is roughly 1.25-1.4× base salary for employees, or opportunity cost for founders. Always include maintenance, which most people forget.

What is a realistic maintenance cost for an automation?

Annual maintenance ranges from 4-10 hours for simple deterministic automations with one API, 15-30 hours for medium workflows with 2-3 integrations and some LLM use, and 40-80+ hours for complex LLM agents with many integrations. Multiplied by a senior engineer's loaded hourly rate, a medium automation typically costs $1,500-$3,500 per year just to keep running. APIs deprecate, models get retired, and business logic shifts, so this line is non-negotiable.

When should I not automate a task?

Skip automation when total task time is under ~50 hours per year, when inputs are highly variable so every instance is structurally different, or when a $20/month SaaS tool already solves it. Low-frequency tasks like monthly invoicing for 6 clients (about 16 hours/year saved) usually don't beat build plus maintenance costs. Batching the work manually or using templates is often the correct answer.

How long does it actually take to build a small AI automation?

A realistic small-but-production automation — like classifying support emails, drafting replies, and queuing edge cases — takes 15-40 hours of senior engineering time. That includes auth refresh handling, retry logic, a basic admin UI, monitoring, and a kill switch. If someone quotes 4 hours, they're quoting a demo, not a system. Add 10-20% on top for discovery and spec time.

What is loaded hourly cost and why does it matter for automation ROI?

Loaded hourly cost is the total cost of an hour of work including salary, payroll taxes, benefits, and overhead — typically 1.25-1.4× the base salary for full-time employees. For founders or contractors, use opportunity cost: what you could earn on your highest-value billable work in that hour. A founder billing $150/hr loses $150 per hour spent on manual tasks, even though no cash leaves the account. Using the wrong number is how people justify builds they can't actually afford.

Work with BizFlowAI

If you'd rather have this built for you, that's what we do: production AI automation for solo founders and small teams — agents, integrations, and document pipelines that actually ship.

Book a free discovery call — 30 minutes, we map the highest-ROI automation in your workflow. No pitch deck, just engineering.

More guides like this on the BizFlowAI blog.