SLA Wait-Time, Erlang B, and Abandonment Calculator

Your call center signed a 90/30 SLA: 90% of calls answered within 30 seconds. The contract attaches a $2,000-per-percentage-point penalty if monthly compliance slips below 87%. Hit 86% in October and you owe $4,000. Hit 80% and you owe $20,000. The math isn’t optional anymore.

Average wait time is the wrong metric for that contract because the penalty is keyed to a percentile, not a mean. An average of 18 seconds sounds great until you realize 22% of callers wait over a minute. The 90/30 SLA is breaching at 78%, and you owe $24,000 for the month. The mean hides the tail. SLA-bound work always lives in the tail.

This page solves three problems that contract-bound operations face every month: hitting a percentile target with Erlang C, sizing for Erlang B (when callers can’t queue and rejected requests are lost), and accounting for abandonment with Erlang A. For a general M/M/1 or M/M/c primer covering utilization, queue length, Little’s Law, and average wait time, see the general queueing theory and M/M/c primer. This tool is for the contract.

Three contract patterns dominate. 80/20 is the legacy benchmark from 1990s telephony: 80% of calls answered in 20 seconds. 90/30 is the modern enterprise standard. 95/30 or 95/15 show up in regulated industries (financial services, healthcare triage) where slow service becomes a compliance issue, not just a customer-experience one. Each tightening costs disproportionately more headcount, and the math tells you exactly how much.

Most ops leads work the problem backward: given a contractual percentile target and a known arrival rate, what’s the minimum agent count? Fix λ (arrival rate from your historical data, peak hour, not daily average), set the target P(W ≤ t) (e.g., 0.90 for 30 seconds at a 90/30 SLA), and iterate c upward. At each value of c, compute the Erlang C probability and the resulting P(W ≤ t). Stop when the probability clears the target. The calculator does this with a bisection search.

Three numbers that practitioners get wrong here. Peak-hour arrival rate, not daily average. If you receive 500 calls/day across a 9-hour window, the average is 56/hour, but the peak hour might handle 110 calls. Staff to peak. Effective service rate, not gross talk time. Add wrap-up time, after-call work, and post-call notes to the average handle time. An agent who talks for 4 minutes and wraps for 90 seconds has μ ≈ 10.9/hour, not 15/hour. Shrinkage. The c the model returns is the number of agents available right now. Schedule for c divided by (1 minus shrinkage). With 25% shrinkage (breaks, training, admin time, sick leave averaged across the workforce), 13 agents available means roughly 17 agents on the roster.

The cost of tightening the SLA target is convex. Going from 80/20 to 90/20 with a fixed λ might add 25% to your headcount. Going from 90/30 to 95/30 might add another 25%. The last 5 percentage points of compliance get expensive. Always compute compliance at c, c+1, c+2 and present the table to the contract owner before signing anything.

Erlang C assumes infinite queue capacity: if all servers are busy, callers wait until one frees up. That’s a useful approximation for call centers with patient customers, but it’s wrong for systems where blocking is the actual outcome.

Erlang B handles the loss case. If all c servers are busy, the next arrival is rejected. In telephony that’s a busy signal. In modern systems it’s a 503 Service Unavailable, a “no available agent” message, or a hangup. The blocking probability with offered load A and c servers is B(c, A) = (A^c / c!) divided by the cumulative sum of Aⁱ/i! from i = 0 to c.

Where Erlang B is the right model: emergency-room bed allocation (no one waits in a hallway forever, they get diverted), legacy phone networks where there are physical trunk limits, modern API gateways with strict concurrency caps where excess requests get rejected with a backoff header, and high-end retail support where overflow callers get routed to an IVR or callback queue rather than left waiting.

The intuition difference: Erlang C asks “how long will I wait?” Erlang B asks “what fraction of arrivals get turned away?” If your contract specifies a maximum block rate (B ≤ 0.02 means at most 2% of calls rejected), Erlang C doesn’t model that constraint at all. It assumes everyone eventually gets served, which guarantees zero block rate by construction.

Practitioner shortcut: for the same offered load A, Erlang B always returns a higher probability of immediate service than Erlang C, because rejected callers don’t pile up in a queue and crowd out new arrivals. If your real system has callers who hang up after 10-15 seconds of waiting, the truth lies somewhere between the two formulas. Erlang A is the bridge.

Real call-center data almost never matches Erlang C exactly because real callers don’t wait indefinitely. After 30, 60, or 90 seconds, a fraction of them hang up. That fraction grows with wait time. Erlang A (sometimes called the M/M/c+M model in academic queueing literature, with origins in the Palm distribution work of the 1940s) extends Erlang C with an abandonment rate θ: each waiting caller abandons at rate θ per unit time, modeled as exponential patience.

The formula is messier than Erlang B or C because the abandonment process competes with the service process for each waiting caller. Numerical solution methods (continued fractions, Krishnamoorthi's 1963 derivation) replace the closed forms used in Erlang B and C. For practitioners, the operational interpretation matters more than the derivation.

Two parameters change the answer. The abandonment rate θ usually comes from your call-center data: if 50% of callers who wait more than 60 seconds hang up, θ ≈ ln(2)/60 ≈ 0.69 per minute. Most consumer call centers run at θ ≈ 0.5 to 1.0 per minute. The other parameter is the wait threshold callers tolerate before they start leaving (often 15 to 45 seconds), after which the abandonment rate climbs steeply.

Why this matters for the SLA: an Erlang C model that ignores abandonment overstates capacity needs. The model thinks all those callers wait the full duration. In reality, half of them hung up and the queue is shorter than predicted. Conversely, abandonments are revenue-affecting on their own. A caller who hangs up doesn’t get served at all, which means they don’t count against the SLA percentile (because they weren’t answered) but they do count against your customer-retention numbers. Erlang A captures both effects. WFM tools that use Erlang A (NICE IEX, Genesys WFM, Verint Monet) typically run 10 to 20% leaner than tools that default to Erlang C.

How an SLA penalty is structured determines whether the math actually protects either party. Three common patterns, each with a real implementation gotcha.

Per-percentage-point penalties. Compliance below the target triggers a per-point penalty: $2,000 per point under 87% on a 90/30 SLA. The math is clean. The implementation gotcha is the measurement window. Monthly aggregates can hide a really bad week. A 30-day window with one disastrous Monday morning that breached for 4 hours can still hit 89% overall while costing 12,000 customers a poor experience. Negotiate measurement windows to be no longer than the period of business impact, often weekly, not monthly.

Tiered breach thresholds. Tier 1 (compliance 85 to 89%) costs $2,000/point. Tier 2 (80 to 84%) costs $5,000/point. Tier 3 (below 80%) becomes a service credit equal to a month’s fee. The penalty discontinuities are intentional: the cost becomes punishing exactly where the customer experience falls off a cliff. The implementation gotcha is what counts as the “primary” call type. If your contract excludes after-hours and emergency callbacks, those calls effectively run uncapped from a penalty standpoint. Read the exclusions before quoting capacity.

Make-good provisions. Failure to hit the SLA two months in a row triggers free service for the third month. The maximum loss is fixed and easy to model financially, but it incentivizes the wrong behavior on the provider side: hitting the SLA in alternating months becomes the optimal strategy from a pure-cost standpoint. Real customers notice that pattern fast.

Workforce-management software in production today (NICE IEX, Verint Monet, Genesys Cloud WFM, Calabrio) computes Erlang C, Erlang B, or Erlang A internally and exposes the percentile target as a contract input. They don’t change the math. They just make it operational at 15-minute intervals across thousands of agents, with shrinkage, schedule adherence, and skill-routing layered on top.

The full set of formulas the calculator uses, with assumptions baked in:

A B2B SaaS support team signed a 90/30 SLA on premium customers with a $2,000-per-percentage-point penalty below 87% compliance, measured weekly. Peak-hour arrival rate λ = 90 calls/hour (verified from CRM exports of the busiest hour over the last six weeks). Average handle time 5.5 minutes including wrap-up. Service rate per agent μ = 10.9/hour.

Offered load: A = 90/10.9 = 8.26 Erlangs. Stability requires c ≥ 9.

c = 11: ρ = 0.751. Erlang C ≈ 0.30. P(W ≤ 30s) ≈ 0.77. Below 90% target, well below the 87% breach threshold. This staffing level breaches every week.

c = 12: ρ = 0.689. Erlang C ≈ 0.20. P(W ≤ 30s) ≈ 0.86. Still below the 87% breach threshold. Penalty would be roughly $2,000 × (87 − 86) = $2,000/week.

c = 13: ρ = 0.636. Erlang C ≈ 0.13. P(W ≤ 30s) ≈ 0.91. Clears the 90% target, well above the 87% breach threshold. Safe.

After 25% shrinkage, schedule 13 / 0.75 ≈ 17 agents on the roster during peak. The cost of the 13th agent (vs. 12) might be $5,000/week loaded. The avoided penalty is $2,000/week plus the goodwill of staying compliant. Net case: +$3,000/week of staffing cost is a clear win against the recurring penalty exposure.

If abandonment is meaningful (say 30% of callers waiting longer than 60 seconds hang up), an Erlang A model would let you stay at c = 12 and still hit compliance because some long-wait callers no longer count against the percentile. Whether to plan around that reality depends on what the contract counts: if abandoned calls count as “not answered” in the breach math, you can’t use Erlang A for sizing. Read the contract before picking the model.