menu_bookGyanByte
arrow_backBACK TO BUILDING VOICEBOTS — TELEPHONIC & BROWSER, THE REAL ENGINEERING
Lesson 11Building Voicebots — Telephonic & Browser, the Real Engineering5 min read

Cost Engineering: Make It Cheap

October 28, 2026

TL;DR

A voicebot's cost is per-minute: STT + LLM + TTS + telephony + infra. In an illustrative breakdown, a PREMIUM stack (Deepgram + ElevenLabs + premium LLM + RAG) runs ~₹8.2/min while a CHEAP stack (self-host Whisper + Sarvam TTS + cheap LLM, no RAG) runs ~₹1.3/min — about 6× cheaper for the same call. TTS is usually the single biggest lever: ElevenLabs alone (~₹5/min) can exceed the whole cheap stack. The nine levers, biggest first: pick a cheaper TTS (Sarvam/Google over ElevenLabs), cache TTS audio, use a small fast LLM, skip RAG when you can, self-host STT at scale, prefer the browser (no telephony charge), keep replies short, batch/reuse embeddings, and end dead air fast. Stack them and a well-optimised bot runs at a fraction of a naive one with no loss a caller would notice. All figures illustrative — compute your own.

A voicebot can be a wonderful demo and a terrible business if it costs more per call than the call is worth. Because voicebots bill per minute across several services, costs add up fast at scale — a helpline doing 10,000 minutes a day is a very different bill depending on your choices. The good news: the difference between a naive stack and a well-engineered one is enormous (illustratively ~6×), and most of the savings cost the caller nothing in experience. This lesson shows where the money goes and how to cut it. (Every figure here is illustrative — provider pricing shifts constantly, so use this as a model to compute your numbers.)

Where the Money Goes

Your per-minute cost is the sum of the pipeline: STT + LLM + TTS + telephony + infrastructure. Here are two example stacks, same one-minute call, very different bills.

What a voice minute actually costs: two stacks per minute of conversation, illustrative rupees, verify current pricing. PREMIUM stack: STT Deepgram 0.66, TTS ElevenLabs 5.16, LLM premium plus RAG 1.70, Telephony 0.70, about 8.22 rupees per minute. CHEAP stack: STT Whisper self-host 0.15, TTS Sarvam 0.40, LLM cheap no RAG 0.03, Telephony 0.70, about 1.28 rupees per minute. The cheap stack is about 6x cheaper, same call: premium (Deepgram plus ElevenLabs plus premium LLM plus RAG) about 8.2 per min; cheap (self-host Whisper plus Sarvam TTS plus cheap LLM no RAG) about 1.3 per min, about 6x less; TTS is the single biggest lever, ElevenLabs alone (about 5 per min) can exceed the WHOLE cheap stack; telephony (about 0.7 per min) is pure cost the BROWSER channel avoids entirely (Lesson 2); at 10,000 minutes/day that's about 13,000/day vs about 82,000/day, the stack choice is the business case. All figures illustrative; provider pricing changes, compute YOUR numbers before committing

Read the two stacks:

  • Premium (Deepgram STT + ElevenLabs TTS + a premium LLM with RAG + telephony) ≈ ₹8.2/min.
  • Cheap (self-hosted Whisper STT + Sarvam TTS + a cheap LLM, no RAG + telephony) ≈ ₹1.3/min — about 6× less for the same call.

Two things jump out. First, TTS is the single biggest lever: ElevenLabs alone (~₹5/min in this example) can cost more than the entire cheap stack. Your TTS choice (Lesson 5) dominates the bill. Second, telephony (~₹0.7/min) is a floor the browser channel avoids entirely (Lesson 2) — for browser/app users you simply don’t pay it. At scale the gap is the business case: 10,000 minutes/day is roughly ₹13,000/day vs ₹82,000/day — ~₹25 lakh/year of difference from stack choices alone.

Nine Levers to Make It Cheap

Here are the levers, biggest savings first. Most are invisible to the caller.

Nine ways to make a voicebot cheap: biggest savings first, cut cost without wrecking the experience. 1 Pick a cheaper TTS: Sarvam/Google instead of ElevenLabs, the number 1 saving. 2 Cache TTS audio: many replies repeat, store and reuse the synthesized audio. 3 Use a small fast LLM: cheaper per token AND lower latency, reserve big models for hard turns. 4 Skip RAG when you can: prompt facts or structured lookups cost far less than retrieval. 5 Self-host STT (Whisper): cheapest at scale once you have steady volume. 6 Prefer browser (WebRTC): no per-minute telephony charge for app/web users. 7 Keep replies short: fewer output tokens plus less TTS audio equals less money and less latency. 8 Batch and reuse embeddings: embed scheme docs once, not per call. 9 End dead air fast: detect silence/abandonment and hang up, don't bill idle minutes. Stack these: a well-optimised voicebot can run at a fraction of a naive one, with no loss a caller would notice
  1. Pick a cheaper TTS. The #1 saving. Sarvam or Google instead of ElevenLabs often cuts the biggest line item by ~10×, for Indian voices that are perfectly good for most use cases (Lesson 5). Reserve premium voice for where quality is the product.
  2. Cache TTS audio. Many replies repeat — greetings, “please hold,” common answers (Lesson 9). Synthesize once, store the audio, reuse it. Free and instant thereafter, and it cuts latency too (Lesson 8).
  3. Use a small, fast LLM. Cheaper per token and lower time-to-first-token (Lessons 6, 8). Route only genuinely hard turns to a bigger model; most turns don’t need it.
  4. Skip RAG when you can. Prompt facts or structured lookups cost far less than embedding + retrieval per query (Lesson 9). Don’t pay for RAG you don’t need.
  5. Self-host STT (Whisper). Once you have steady volume, running your own STT on a GPU is cheapest at scale — you trade per-minute API fees for amortised compute (Lesson 4).
  6. Prefer the browser (WebRTC) where you can. App and web users cost no telephony (Lesson 2). Steer users who can use the browser to it; reserve the phone line for those who need it.
  7. Keep replies short. Fewer output tokens (LLM cost) and less audio to synthesize (TTS cost) — and it’s more listenable and faster too (Lessons 6, 8). Verbosity pays triple.
  8. Batch and reuse embeddings. Embed your scheme documents once (Lesson 9), not per call. Precompute, don’t re-embed on every query.
  9. End dead air fast. Detect silence or an abandoned call and hang up gracefully (Lesson 12) — don’t bill idle minutes where STT/telephony keep running while nobody’s there.

The key insight: these stack. Each is a modest saving; together they take you from the premium ₹8/min toward the cheap ₹1/min — a well-optimised voicebot runs at a fraction of a naive one, and a caller wouldn’t notice the difference (a good Sarvam voice, a fast small model, and a cached greeting feel fine). The savings come from engineering, not from degrading the experience.

How to Think About It

A few framing principles:

  • Model your real traffic. Build a little spreadsheet (or script, as this course did) with your expected minutes, turns per call, languages, and the providers you’re considering, and compute ₹/min and ₹/day. The stack decision is a business decision; make it with numbers, not vibes.
  • Optimise the biggest line first. TTS, then telephony (via browser), then the LLM — in roughly that order of impact for a typical voicebot. Don’t micro-optimise STT while paying ElevenLabs for everything.
  • Match spend to value. A high-value, low-volume concierge bot can justify premium everything; a high-volume citizen helpline must be lean. Spend where the use case warrants it.
  • Pricing changes — recompute. Providers change prices and launch cheaper models often. Revisit the math periodically; a quarterly recompute can save a lot.

And the honest caveat one more time: all the numbers in this lesson are illustrative. They show the shape — TTS dominates, browser saves telephony, cheap stacks are ~6× less — which is stable, but the exact rupees are not. Compute your own before committing budget.

Pitfalls to Avoid

  1. Defaulting to premium TTS. It’s usually your biggest cost (~10× cheaper alternatives exist). Pick a cost-effective Indic TTS unless quality is the product.
  2. Not caching repeated audio/answers. Callers repeat questions; cache TTS and answers to cut both cost and latency (Lessons 5, 9).
  3. Using a big LLM for every turn. Most turns need a small fast model; reserve big ones for hard cases. Cheaper and faster (Lessons 6, 8).
  4. Paying for telephony you could avoid. Browser/app users cost no telephony. Steer them to the browser where possible (Lesson 2).
  5. RAG everywhere. It adds cost and latency; use prompt/structured data where they suffice (Lesson 9).
  6. Billing idle minutes. Silence or abandoned calls keep meters running. Detect and hang up gracefully (Lesson 12).
  7. Guessing instead of modelling. Compute ₹/min on your real traffic; the stack choice is worth lakhs at scale. (And recompute as pricing changes.)

Quick Recap

  • Cost is per-minute: STT + LLM + TTS + telephony + infra. Illustratively, premium ≈ ₹8.2/min vs cheap ≈ ₹1.3/min — ~6× difference for the same call.
  • TTS is usually the biggest lever (ElevenLabs alone can exceed the whole cheap stack); telephony is a floor the browser avoids.
  • Nine stacking levers: cheaper TTS, cache audio, small fast LLM, skip RAG when you can, self-host STT at scale, prefer browser, keep replies short, reuse embeddings, end dead air fast — all largely invisible to the caller.
  • Model your real traffic, optimise the biggest line first, match spend to value, and recompute as pricing changes. All figures illustrative.

Next lesson: getting it into production and keeping it there — testing, monitoring, scaling to many concurrent calls, and handling the messy failure paths where voicebots break.

voicebotcostpricingsarvamelevenlabsoptimization
arrow_back PreviousUse Cases: Schemes, Gatepass & MoreNext arrow_forwardProduction: Test, Monitor, Scale