Honest automation ROI

ROI conversations around automation often collapse into invented percentages: "save 40 hours a month" with no measurement behind them. This guide gives you a worksheet-style approach you can run in an hour with a spreadsheet — enough to decide whether to pilot, postpone, or kill an idea before anyone writes code.

Start with time, not technology

Pick one workflow and estimate:

• Frequency — how many times per week or month it runs.
• Minutes per run — include context switching, not just keystrokes.
• Who is involved — hourly cost is optional; role scarcity matters more for small teams.

Example: triaging 30 support mails × 4 minutes each × 5 days ≈ 10 hours/week. If only half are repetitive, automatable portion ≈ 5 hours/week. Write numbers down — gut feel is usually wrong.

Estimate automation yield (realistically)

Automation rarely eliminates 100% of a task. Use conservative yields:

• Scripts on stable inputs — 60–80% time reduction after pilot.
• Supervised agents — 30–50% on preparation; human review time remains.
• Exploratory / messy inputs — 0% until you have a month of shadow-mode data.

Subtract new overhead: monitoring alerts, monthly FAQ updates, re-auth when APIs change, reviewing bad drafts. Add 15–30% of gross savings as upkeep unless you have a named owner.

One-time and ongoing costs

Build cost — scoped pilot with papsbot or internal dev time. Ask for written limits: what is in v1, what is explicitly out.

Run cost — API fees, model tokens, extra SaaS seats, VM for local setups. Token-heavy agents on high volume can exceed labour savings if nobody watches the meter.

Opportunity cost — what does your technical person not do while building this? For teams without spare eng time, a purchased pilot may beat a six-month internal side project.

When automation loses on ROI

Say no (for now) when:

• Low frequency — task runs monthly and takes 20 minutes. Build cost never pays back.
• Unstable process — rules change weekly; you will rewrite automations constantly.
• High exception rate — >30% of cases need bespoke handling; agent spends more time escalating than helping.
• Hidden risk — wrong send costs more than manual delay (legal, billing, reputation).
• No owner — nobody will update the knowledge base or fix broken webhooks.

We document these stop conditions openly — see our don't automate example. A checklist plus calendar reminder often beats a fragile bot.

When automation wins

• Same inputs, same steps, measurable volume (daily/weekly).
• Errors are costly but preventable with logging and alerts.
• Knowledge is centralised enough to index or query.
• A human checkpoint is acceptable (draft review, approve send).
• Someone owns maintenance for at least six months.

Lead routing from web forms and weekly status reports are classic wins — see our playbooks.

A simple payback formula

Let H = hours saved per month (after upkeep), C = monthly run cost in hours-equivalent or currency, B = one-time build cost. Rough months to pay back:

payback_months ≈ B / (H − C) (when H > C)

If payback > 12 months and the process may change, pilot small or wait. If payback < 6 months and risk is supervised, prioritise the pilot.

We do not publish guaranteed ROI — your tools and team differ. The formula is for ordering priorities, not investor decks.

Pilot design that protects ROI

1. Shadow mode — agent drafts, human sends; measure edit time.
2. Success metrics — time per case, escalation rate, error count — not vanity "AI handled X%".
3. Stop rule — if escalations >40% after two weeks, narrow scope or stop.
4. Handoff — runbook so savings persist if we are not on retainer.

Worksheet: estimate one workflow in 30 minutes

Open a spreadsheet and create four rows: Manual minutes per run, Runs per month, Expected automation yield (%), and Monthly upkeep hours. Multiply the first two for gross manual hours. Apply the yield to get estimated saved hours. Subtract upkeep. That net figure is what you compare against build cost.

Example: 15 minutes × 80 runs/month = 20 hours gross. A script with 70% yield saves ~14 hours, minus 2 hours upkeep → 12 hours net. If build cost is 24 hours of contractor time, payback is roughly two months if the process stays stable. If rules change monthly, double the upkeep row until you have six months of stable operation data.

Comparing build paths

Path	Best when	Watch for
Internal script	Stable API, dev time available, low risk	Bus factor — document before the author leaves
No-code automation	Simple triggers, citizen integrator on team	Per-task pricing at volume; export limits
Supervised agent pilot	Messy language inputs, multiple tools	Token costs; review time still counts as labour
External setup (papsbot)	No spare eng weeks; need handoff docs fast	Scope creep — keep v1 to one workflow

The cheapest path on paper fails when nobody maintains it. Price upkeep hours honestly — even two hours a month changes payback on small workflows.

Team size changes the math

A five-person team feels pain when the founder triages mail daily — saved hours are scarce-role hours, worth more than the spreadsheet suggests. A thirty-person team might already have ops staff; automation frees them for exceptions, not headcount reduction. Frame ROI as capacity for higher-value work, not layoffs. That framing also matches how supervised agents actually deploy: fewer hours on prep, same people on judgement.

Record who approved each automated send during the pilot. Approval time is part of the true cost. If approvers skim drafts because volume rose, quality risk climbs — that belongs in the ROI sheet as oversight minutes, not zero. Count those minutes in the same column as manual handling time.

Privacy and compliance affect ROI

Handling PII or regulated data may require local deployment or DPA reviews — that adds build time but avoids breach cost. Read data privacy in automation before assuming cloud APIs are free.

When leadership asks for "AI" without a workflow

Redirect the conversation to a single measurable task: "Which inbox, form, or report costs the most hours each week?" If no one can name it, spend two weeks logging time before estimating ROI. Broad "digital transformation" budgets without a workflow attached usually fund demos, not durable automation. A one-page brief — task, frequency, tools, approval point — is enough to decide script vs agent vs wait.

Capture baseline numbers before the pilot: median minutes per task, error rate, and who gets interrupted. After four weeks of supervised automation, compare the same metrics. If saved minutes are smaller than upkeep plus review time, scale down or switch to a simpler script. Honest ROI reviews kill bad projects early — that is a success, not a failure.

Share the spreadsheet with finance as assumptions, not promises. Label each cell — measured, estimated, or unknown. Unknown cells are where the pilot should focus data collection first.

Next steps

Run your numbers on one workflow. Then use the readiness check to sanity-check script vs agent vs skip. For hands-on help scoping a pilot, see services or contact us.

Bring your spreadsheet to the first call — even rough cells help us agree whether a two-week pilot is worth writing up. We use the same yield assumptions here; surprises usually mean the frequency or exception rate was optimistic, not that automation never works. Revisit the sheet after the pilot either way — wins and stops both teach the next priority. File it beside the runbook so the next hire inherits the reasoning, not only the scripts.