Why architecture matters here
Video streaming architecture matters because bandwidth is expensive and users are impatient. Every extra second of startup drops engagement measurably. Every rebuffer event drops it more. The wrong ABR algorithm sends users to 240p on connections that could handle 1080p; the wrong CDN partner leaves cache misses that hit origin at exactly the moment a viral event demands scale.
Cost is dominated by egress bandwidth. A well-tuned platform hits CDN cache rates of 95%+ and negotiates region-appropriate pricing; a poorly tuned one gets stuck on cache misses that pay both CDN and origin egress. Multi-CDN and origin shielding reduce cost dramatically for teams that adopt them.
Reliability under viral load is where great architectures separate from good ones. A well-designed platform handles a 10x spike from a viral video without rebuffering; a poor one melts under it. Capacity planning, CDN diversity, and origin fanout controls are what get you through.
The architecture: every layer explained
Walk the diagram top to bottom.
Ingest. Source video enters via RTMP (legacy but ubiquitous), SRT (modern, more resilient), or WebRTC (for low-latency contribution). Ingest points are geographically distributed close to producers to reduce upload latency.
Transcoder. Produces the ABR ladder — multiple bitrate/resolution versions of the same content. Encoders (NVIDIA NVENC on GPU, AMD, x264/x265 on CPU) transcode into H.264, H.265, or AV1. AV1 saves 30% bandwidth but costs more to encode.
Packager. Wraps encoded segments into HLS (Apple, Safari native) or DASH (everyone else) manifests. Chunked CMAF unifies both from the same source. Segment length trades startup time (shorter) vs coding efficiency (longer); 2-4 seconds is standard.
Origin Storage. S3, GCS, or a specialized origin. VOD content sits here for years; live content is written continuously and expired quickly. Object versioning helps with rollback.
CDN Distribution. Akamai, Cloudflare, CloudFront, or a hybrid multi-CDN. Content is cached at edge PoPs close to viewers. Origin shield (a middle-tier cache) reduces origin fetches by consolidating requests from many PoPs.
Player (ABR). hls.js (web), dash.js (web), Shaka Player (Google, cross-platform), ExoPlayer (Android), AVPlayer (iOS native). ABR algorithms — BOLA, MPC, model-based — pick the next segment's bitrate based on buffer state and estimated bandwidth.
DRM + Token Auth. Widevine (Google, most Android/web), FairPlay (Apple), PlayReady (Microsoft) protect premium content. Signed URLs and token-based auth prevent hotlinking.
Analytics. Quality of Experience (QoE) metrics: startup time, rebuffer rate, average bitrate, video start failures. Engagement metrics: watch time, completion rate, drop-off points. Feed product and operations.
Ad Insertion. Server-Side Ad Insertion (SSAI) stitches ads into the same manifest as content, defeating ad blockers. Client-side ad insertion is simpler but ad-blockable. VAST/VMAP are the standard ad request protocols.
Live vs VOD. Live has millisecond-to-second latency SLOs, short retention, and reference-clock synchronization. VOD has second-to-minute startup targets and long retention. Both share transcode/package but differ in the whole pipeline downstream.
End-to-end VOD + live flows
Trace VOD playback. A user opens the app and clicks play on a movie. The player calls the manifest URL. The CDN checks cache; hit — returns the manifest with signed URLs for segments. The player parses the manifest, gets ABR ladder entries (240p through 4K), and picks a starting bitrate based on estimated bandwidth (typically starts conservative to minimize startup time).
The player requests the first segment. CDN edge cache hit; ~40 ms latency; the player buffers 2-4 seconds and starts playback. Meanwhile the ABR algorithm samples bandwidth and adjusts. Buffer grows healthy; ABR ramps up to 4K.
The user seeks forward. The player switches to segments near the seek point; CDN cache may or may not have them. First seek at a rare offset may miss cache; second viewer hitting the same offset gets a cache hit.
Trace live streaming. A concert starts. Ingest receives WebRTC contribution from the venue. Transcoder produces the ABR ladder in near real-time. Packager writes CMAF segments continuously and updates the manifest every few seconds.
Millions of viewers open the stream. Each fetches the manifest, ABR algorithm picks bitrate, segments flow. CDN scales via edge fanout and origin shielding — a single origin fetch fans out to millions of edge deliveries.
Latency budget for near-live: 8-15 seconds glass to glass. Low-latency HLS (LL-HLS) and DASH LL push this to 2-5 seconds with careful chunk-transfer encoding and preload hints.