Server-side ad insertion stitches ads into the stream itself — no client SDK to block, one continuous video — by giving every viewer a personalized manifest. Read that sentence as a delivery engineer and the danger is obvious: “personalized” and “cache” are natural enemies, and a careless SSAI deployment un-caches an entire video estate. The whole craft is keeping the personalization confined to the smallest possible object.
How SSAI actually touches delivery
The stitcher sits between packager and player: at each ad break it calls ad decisioning, receives creatives for this viewer, and writes a manifest that interleaves content segments with ad segments — transcoded to match your ladder so the player never knows the difference. Three object classes emerge, and they want three different treatments: session manifests (unique per viewer, refreshed through playback), content segments (identical for everyone, exactly as before SSAI), and ad segments (shared across every viewer who received that creative — far fewer variants than viewers). Delivery goes wrong when these classes blur: manifests cached and viewers receive someone else’s ad timeline, or segments personalized and hit ratio collapses to zero.
The golden rule: personalize manifests, share segments
The invariant to engineer and then test: segment URLs must be identical across sessions; only the playlist that orders them may differ. Session manifests are uncacheable by design — no-store, or a bypass rule on the manifest path — and their per-viewer identity should ride in the path or a cookie the cache never keys on for media. The failure to hunt is session tokens leaking into segment URLs: one stitcher configuration flag (session parameters appended to every URL rather than the playlist alone) converts your best-cached objects into millions of single-viewer variants — the same fragmentation mechanics as cache-key design, at video scale. The acceptance test is one command long: play two sessions, diff the segment URLs. Identical segments, different playlists: correct. Anything else: stop and fix before scale finds it for you.
Caching the ads themselves
Ad segments are shared media and should cache like content — but their population behaves differently: creatives churn with campaigns, the active set at any moment is small and hot (a break serves the same handful of creatives to a large audience slice), and each creative must exist across your full ladder. Give transcoded creatives immutable versioned paths with long TTLs, and pre-transcode plus pre-warm the creatives scheduled for big live breaks — an ad pod that misses cache at a sports-final break is a synchronized origin spike at the worst moment, the same arithmetic as any launch object in cache warming. Watch hit ratio on the ad path separately from content: blended numbers hide a cold creative pipeline behind a warm library.
Manifest service placement and protection
With segments cached, the stitcher becomes the scaling bottleneck: every active viewer polls it for playlist updates (every few seconds for live), each request doing per-session work. Place it close to viewers — regional instances or edge-adjacent deployment — because manifest latency lands directly on startup time and, for live, on how close to the edge players can ride. Protect it like the origin it is: it must not be reachable except through your delivery hostname, per origin protection, and it deserves rate limits, because one misbehaving player polling at 10× is invisible in segment traffic but real load on a stitcher. Design its failure mode deliberately: on decisioning or stitcher errors, serve the content-only manifest (slate or skip) rather than erroring the stream — an unfilled break costs revenue once; a stalled player costs the viewer.
Beacons, DAI variants and the QA checklist
Ad verification fires tracking beacons per viewer per quartile; whether client-fired (from playlist metadata) or server-fired (by the stitcher), they are per-user, uncacheable by definition, and belong on their own hostname and infrastructure so measurement traffic never contends with media — and never gets cached into fraudulent consistency. The same architecture covers SSAI’s variants: FAST channels are SSAI at maximum manifest churn, and hybrid server-guided insertion moves some assembly client-side but keeps the identical delivery split. The standing QA list: two-session segment-URL diff (section two) on every stitcher upgrade; manifest path confirmed uncached at the edge; ad-path hit ratio on its own dashboard; stitcher latency and error rate alarmed; slate fallback tested by killing decisioning in staging. Ad-supported delivery done right costs almost nothing over plain delivery — the entire tax is concentrated in that one small, uncacheable, load-bearing playlist.