Every support automation pitch ends the same way: someone in finance asks "what's the return?" and the room goes quiet. People throw around "deflection rate" and "efficiency gains" without a number attached.
Let's fix that. Below is a concrete model you can run before writing a line of chatbot code, plus the code to calculate it. No hand-waving.
The core equation
Chatbot ROI is not mysterious. It's a comparison between what you save and what you spend:
ROI = (Annual Savings - Annual Cost) / Annual Cost
The hard part is not the ROI line. It's building an honest Annual Savings number. Most teams inflate it because they assume 100% resolution. Real bots resolve a fraction and escalate the rest.
The variables that actually matter
- Ticket volume - tickets per month
- Cost per human ticket - fully loaded agent cost / tickets handled
- Automation rate - % of tickets the bot fully resolves without a human
- Containment cost - what each bot-handled ticket costs you (LLM tokens, infra, platform)
- Escalation drag - bot-handled-then-escalated tickets are more expensive than a direct human handoff
That last one is where naive models break. If your bot fumbles and hands off cold, you pay for the LLM call and the agent time. Model it.
The model in code
def chatbot_roi(
monthly_tickets: int,
cost_per_human_ticket: float, # fully loaded, e.g. $6.50
automation_rate: float, # 0.0 - 1.0, fully resolved by bot
escalation_rate: float, # of remaining, how many bot touches then escalate
cost_per_bot_ticket: float, # tokens + infra, e.g. $0.12
escalation_penalty: float, # extra human minutes cost from cold handoff
build_cost: float, # one-time build/integration
monthly_platform_cost: float, # n8n, vector db, hosting, etc.
):
annual_tickets = monthly_tickets * 12
resolved_by_bot = annual_tickets * automation_rate
escalated = annual_tickets * (1 - automation_rate) * escalation_rate
pure_human = annual_tickets - resolved_by_bot - escalated
# Cost of the old world: everything handled by humans
baseline_cost = annual_tickets * cost_per_human_ticket
# Cost of the new world
bot_cost = (resolved_by_bot + escalated) * cost_per_bot_ticket
human_cost = pure_human * cost_per_human_ticket
escalation_cost = escalated * (cost_per_human_ticket + escalation_penalty)
platform = monthly_platform_cost * 12
new_cost = bot_cost + human_cost + escalation_cost + platform
annual_savings = baseline_cost - new_cost
total_cost = build_cost + platform
roi = (annual_savings - build_cost) / total_cost
payback_weeks = build_cost / (annual_savings / 52) if annual_savings > 0 else float("inf")
return {
"annual_savings": round(annual_savings),
"roi": round(roi, 2),
"payback_weeks": round(payback_weeks, 1),
}
print(chatbot_roi(
monthly_tickets=8000,
cost_per_human_ticket=6.50,
automation_rate=0.45,
escalation_rate=0.20,
cost_per_bot_ticket=0.12,
escalation_penalty=2.00,
build_cost=18000,
monthly_platform_cost=900,
))
Run that and you get roughly:
{'annual_savings': 214000, 'roi': 7.4, 'payback_weeks': 4.4}
A 4.4-week payback. That's the number that ends the finance conversation - not "we deflect a lot of tickets."
Where these numbers come from
Don't invent the inputs. Pull them.
Ticket volume and cost per ticket live in your helpdesk (Zendesk, Intercom, Freshdesk). Export a quarter of data. Fully loaded cost = (agent salaries + tooling + overhead) / tickets resolved. Most B2B SaaS teams land between $4 and $12.
Automation rate is the one you can't guess. Before building, run a tagging pass over 500 real tickets. Bucket them: password resets, billing questions, "where is my order," edge cases. Sum the buckets a bot can realistically own. If 45% of tickets are five repeatable intents, that's your ceiling - and you won't hit the ceiling in month one.
Escalation rate starts high and falls. Assume 25-35% for the first quarter, dropping as you close knowledge gaps.
The mistakes that make ROI fiction
Counting deflection as resolution
A bot that answers and the user still opens a ticket didn't deflect anything. Only count tickets that close without human touch. Instrument this explicitly - tag every conversation with resolved_by_bot vs escalated.
Ignoring maintenance
That monthly_platform_cost should include the human hours to update prompts, retrain retrieval, and review transcripts. Budget 5-10 hours a month. A bot is not a fire-and-forget asset.
Modeling on peak, not average
Holiday spikes make automation look heroic. Use a trailing 90-day average so your CFO doesn't catch you cherry-picking.
The threshold that says "build it"
A quick rule from the projects we run: if payback lands under 12 weeks and automation rate on tagged tickets clears 30%, the build is defensible. Under 6 weeks, it's a no-brainer. Above 20 weeks, your ticket volume is probably too low or your intents too varied - route the budget elsewhere.
The formula's real value isn't the final ROI figure. It's that it forces you to measure automation rate before you build, kill projects that won't pay back, and set instrumentation that proves the number after launch.
Plug in your own numbers. If the payback is measured in weeks, you have your business case. If it's measured in years, you just saved yourself a build.
Originally published at getmichaelai.com
Top comments (0)