AI automation promises efficiency and cost savings, but how do you prove it? Here's a practical framework for measuring ROI that we use with clients, including worked examples and common pitfalls to avoid.
The ROI formula
ROI = (Gains – Costs) / Costs × 100%
Simple in theory, but gains and costs both have visible and hidden components. Let's break them down.
Calculating costs
Development costs (one-time)
- Requirements gathering and process mapping: 20–40 hours
- System design and architecture: 30–60 hours
- Development and integration: 80–200 hours depending on complexity
- Testing and QA: 20–40 hours
- Training and documentation: 10–20 hours
What moves the total: how many systems it connects to, how clean the input data is, whether personal data is involved, and how much human review the process still needs. Ask for a fixed price against a written scope, so the hours above become one number you can plan around.
Ongoing costs (monthly)
- API costs (OpenAI, Anthropic, etc.): scale with volume and with the model you choose
- Infrastructure (hosting, databases): usually the lowest of these lines
- Monitoring and maintenance: 5–10 hours/month
- Model updates and improvements: 10–20 hours/quarter
What moves the run rate: volume, above all. API usage grows with every request, so model your busiest month, not an average one.
Calculating gains
Direct time savings
Measure the time eliminated from repetitive tasks. Example: Customer support automation.
- Before: 300 tickets/month × 8 minutes average = 40 hours
- After: AI handles 70%, reducing to 90 tickets manually = 12 hours
- Time saved: 28 hours/month × your loaded hourly cost (salary plus overhead)
Quality and error reduction
Calculate the cost of errors prevented. Example: Invoice processing.
- Before: 5% error rate on 200 invoices = 10 errors/month
- Cost per error (rework, delayed payments): take yours from last quarter's corrections
- After AI: 1% error rate = 2 errors/month
- Savings: 8 errors/month × your cost per error
Revenue enablement
Harder to measure but often the biggest gain. Example: Sales lead qualification.
- AI scores and prioritizes 500 inbound leads/month
- Sales team focuses on top 100 (vs. random outreach)
- Conversion rate improves from 2% to 5%
- 10 leads → 25 leads closed: 15 extra deals a month × your average deal value
- Credit only 10% of that uplift to the AI and check the case still holds
Scalability gains
Avoid hiring as volume grows. Example: Content moderation.
- Current: 1 FTE handles 1,000 items/month
- With AI: Same FTE handles 3,000 items/month
- Avoided hires: the salary and overhead of the people you would otherwise add
Real-world examples
Example 1: Document extraction for accounting firm
- Investment: a one-off build plus a monthly run cost
- Gains: 60 hours/month saved + 12 errors/month prevented
- Monthly gains: roughly five times the run cost
- Payback period: 6.5 months
- Year 1 ROI: 86%
Example 2: Customer support chatbot for SaaS company
- Investment: the largest build of the three, plus a monthly run cost
- Gains: 80 hours/month saved + improved CSAT → 5% churn reduction
- Monthly gains: roughly six times the run cost
- Payback period: 5.8 months
- Year 1 ROI: 105%
Example 3: Automated product recommendations for e-commerce
- Investment: the lightest build of the three, plus a monthly run cost
- Gains: 8% increase in average order value on 500 orders/month, at a 10% margin
- Monthly gains: roughly twice the run cost
- Payback period: 30 months
- Year 1 ROI: -60% (still worth it for long-term growth)
Common pitfalls
Ignoring change management costs: Budget 10–20% of dev cost for training, process changes, and adoption.
Overestimating time savings: Not all saved time converts to productive work. Use 60–70% as a conservative multiplier.
Underestimating ongoing costs: API usage can spike. Monitor and set alerts to avoid surprises.
Not measuring baseline: Track current performance (time, errors, conversions) before building. You need a comparison.
Forgetting qualitative gains: Faster response times, happier employees, better customer experience. These matter even if hard to quantify.
Framework for your project
- Define the scope: Pick one repetitive, high-volume workflow.
- Measure baseline: Time per task, volume, error rate, current costs.
- Estimate gains: Use conservative assumptions (50–70% automation, not 90%).
- Calculate costs: Get quotes for development, hosting, and API usage.
- Set success metrics: Time saved, errors reduced, revenue impact.
- Build incrementally: MVP first, then expand. This reduces upfront risk.
- Track and report: Monthly dashboards showing actual vs. projected gains.
When AI automation makes sense
High-volume, repetitive tasks with clear rules: yes. Complex judgment calls requiring deep expertise: maybe later. One-off tasks: probably not.
Best candidates: data entry, document processing, tier-1 support, lead scoring, content tagging, scheduling, report generation.
Next steps
Pick one workflow costing you 20+ hours per month. Measure the baseline. Model the ROI using this framework. If payback is under 12 months and you can fund it, start a proof-of-concept.
AI automation isn't magic, but when applied to the right problems, the returns are measurable, repeatable, and compound over time.