A rebuffer is simple mechanics: the player’s buffer drained faster than delivery refilled it. Everything difficult about stalls is in the word “why” — the shortfall can live in the encoding ladder, the player’s adaptation logic, an edge cache, a peering path or the viewer’s WiFi, and fixes aimed at the wrong layer do nothing. So the discipline is an order: measure, localize, attribute, and only then fix — with the fixes themselves ranked by how often they turn out to be the answer.
What a stall actually is
The player maintains a buffer of downloaded-but-unplayed media — typically ten to thirty seconds for VOD, much less for low-latency live — and adaptive bitrate logic tries to keep it healthy by picking rungs the measured throughput can sustain. A stall means that control loop lost: throughput dropped faster than ABR downshifted, or segments arrived late for reasons throughput averages never saw (a cache miss that sent one segment to a distant origin, a slow token check, a TCP connection recovering from loss). That last category matters because it is delivery’s share of the problem — per-segment latency outliers, invisible in bandwidth graphs, visible only in segment download times.
Measure first: the two numbers and their cuts
Two metrics carry the analysis: rebuffer ratio (stall time as a share of watch time) and stall frequency (events per hour of viewing) — ratio for severity, frequency for annoyance, since ten one-second stalls lose more viewers than one ten-second stall. Collect them from the player beacon into your RUM pipeline, and store the dimensions that make localization possible: CDN (and POP where exposed), ISP or ASN, geography, device and player version, connection type, title, live vs VOD, and the bitrate rung at stall time. Aggregates hide everything — a healthy global average routinely conceals one ASN at ten times the stall rate — so the working views are always cuts, and the collection mechanics are in deploying RUM. Choosing thresholds and wiring them to alerts is covered in picking QoE metrics; here we need the raw cuts.
Localize: whose problem is this stall?
Read the cuts like a truth table. Stalls concentrated in one ASN or region, across all titles and both CDNs (if you run two): a network-path problem — congested peering, a throttling ISP — and your lever is routing or a CDN whose connectivity into that network is better. Concentrated on one CDN across regions: a delivery problem — go straight to cache behaviour and segment latency on that platform. Concentrated on specific titles or rungs: an encoding problem — a rung whose real bitrate spikes above its label starves buffers on exactly the connections that chose it. Concentrated on a player version or device class: an ABR or buffer-configuration regression. Spread evenly and low: you are at the noise floor of last-mile networks, and heroics will not move it. For the one-viewer escalation rather than the population view, the request-level walk in debugging behind a CDN applies to segments as well as pages.
The fixes, in the order they usually win
Ordered by hit rate across real estates. First, cache hit ratio on segments: every miss is a latency outlier waiting to stall someone, so misses on popular content mean fragmentation — tokens in cache keys, duplicated packaging — and the levers in raising hit ratio apply verbatim. Second, the ladder: measure each rung’s true peak bitrate against its manifest label and re-encode the liars; add a lower rung if your worst quartile of connections has nowhere safe to sit. Third, ABR and buffer tuning: less aggressive up-switching, a larger buffer target for VOD (startup and stall trade against each other — the other side is startup time), and modern buffer-aware algorithms where the player offers them. Fourth, per-segment tail latency at the edge: hunt p99 segment download times by POP; a single misbehaving shield or an origin doing per-request work it should not (auth on immutable segments) shows up here. Fifth, the network path itself: where one ISP stays bad, the honest fixes are commercial and architectural — steering that ASN to whichever CDN serves it best.
Guardrails: keeping stalls down for good
Rebuffering regresses through changes nobody connects to it: a new player build, a ladder tweak, a CDN config push, a token system that adds per-segment latency. So make the two metrics from section two release guardrails — compared before and after every player and delivery change, cut by the same dimensions — and alert on the cuts, not the global average, because that is where regressions surface first. Keep one standing dashboard: stall ratio and frequency by ASN, CDN and rung, week over week. The estates with the lowest rebuffer numbers are not the ones that fixed stalls once; they are the ones where a half-percent regression in one ASN pages somebody on Tuesday instead of surfacing in churn three months later.