broadcast.ad is the portable, inspectable ad-signal & manifest-control layer that lets broadcasters keep linear-grade control of the ad break while plugging into the ad servers and delivery models they already use, on any cloud, CDN, or on-prem they choose.
Streaming ad revenue leaks across the break: missed SCTE markers, underfilled avails, opaque SSAI reports, vendor-locked workflows, cloud-bound render costs, reconciliation disputes, and makegoods.
broadcast.ad gives broadcasters an independent control plane for the ad break: it validates the signal, enforces your policy, asks the ad server you already use what to play, renders SSAI or SGAI output, and proves what happened. The result is not more ad load. It is better retained revenue from the inventory you already sell.
No cloud tax. Stateless Rust workers run anywhere, from a laptop to bare Kubernetes, with no cloud-proprietary primitives in the path.
Bill what actually aired. Per-avail audit records and automatic ad-server reconciliation close the gap that otherwise turns into discrepancy disputes and makegoods.
Bring your own everything. SCTE-35 in, VAST/VMAP decisioning, HLS or DASH out. It works with the ad servers and players you already run.
Broadcasters need dynamic ad insertion across OTT, FAST, vMVPD and D2C. Today they either surrender the insertion logic to a hyperscaler or build bespoke glue with no standards spine, and either way they lose visibility into the dollars.
Yospace, AWS Elemental MediaTailor and Google DAI all do SSAI and SGAI. Their commercial center of gravity is platform-owned insertion; broadcast.ad's is broadcaster-owned policy, signal, manifest, and proof. With theirs, the control plane lives in someone else's stack: a per-stream cost, hard to debug, and only loosely coupled to your broadcast signaling.
The SSAI to SGAI migration is underway and HLS Interstitials are shipping. Incumbents are bolting SGAI onto SSAI cores. A greenfield build can be render-mode-agnostic from day one.
ESAM (SCTE 130-3) was born in a trusted-network era. In multi-tenant cloud workflows there is no broadly adopted ESAM-native security profile, so identity, replay protection, and policy authorization get bolted on per deployment instead.
Deploy-anywhere cloud independence, a render-mode-agnostic core, and signal-integrity as a first-class product: the combination the incumbents structurally cannot offer at once.
Each one keeps control in your hands instead of a vendor's cloud: your infrastructure, your ad servers, your data, your economics. No incumbent closes all five at once, because each wedge removes a lock-in or per-stream revenue stream their platform is built to sell. Doing all five would mean competing with their own economics.
Cut the per-stream cloud tax. Deploy-anywhere: local lab, private cloud, Linode, OCI, customer infra, Kubernetes. Stateless workers, no cloud-proprietary primitives. The transcode backend is bundled and modular (ffmpeg baseline, swappable) so it never reaches for a cloud's transcode service. Rust's low per-stream footprint makes the cost argument real, not philosophical.
Stop revenue leaking through bad signaling. Conformance: a verifiable SCTE-35/224 conditioning pipeline for provable signal integrity from contribution to avail, where day-to-day revenue leakage lives. Trust (SESAME): a proposed ESAM security profile adding identity, replay protection, and authorization to the messaging layer. Hard to copy.
Run SSAI and SGAI from one stack, with no rebuild when the standard shifts. One session / decision / tracking layer; switchable output as stitched segments (SSAI) or interstitial/event signals (SGAI). No mode leaks into the core: SSAI and SGAI are the only implementors of one Renderer trait. The single most important architecture call, made at the start instead of retrofitted.
Stop paying for impressions you can't prove. First-class per-session telemetry and automatic ad-server reconciliation target the impression-discrepancy leakage, the disputes and makegoods, that incumbents treat as an afterthought. Per-avail audit records, tracing, Prometheus metrics. "Wireshark for broadcast ad insertion."
Honor blackouts, affiliate swaps and regional rules automatically. Frame-accurate boundaries. Graceful underfill and slate. Blackout, affiliate replacement and regionalization honored through POIS policy. Built for linear-grade control, not an OTT tool stretched to fit broadcast.
Plug into the ad servers and players you already run. Output conforms to SCTE-35/224, VAST/VMAP, Apple HLS Interstitials, DASH events, OMID, and the Google DAI Pod Serving component model. Maximum compatibility is a hard constraint: no proprietary wire format, ever.
SCTE-35 in, ad-conditioned manifest out. If you own ad ops, the takeaway is short: every break resolves to something playable and every impression is logged. If you own the architecture, here is exactly how, and where each guarantee is enforced.
async fn decide(&self, avail: &Avail, ctx: &SessionCtx) -> AdDecision;Ad decisioning is structurally infallible. The signature returns AdDecision, not Result, so it has no error variant: timeout, underfill, or an upstream ad-server failure returns AdDecision::no_fill, which the renderer converts into slate or fallback output. "Never errors" is a compiler guarantee here, not a hope.
A clear stance on each layer of the stack keeps the product a control plane, not another demand platform.
| Layer | Answers | Representative players | Our stance |
|---|---|---|---|
| A · Ad decisioning | "Which ad plays?" | Google Ad Manager, FreeWheel, Magnite, SpringServe | Integrate, never compete |
| B · Session / manifest | "How do I personalize per session?" | MediaTailor, Google DAI, Yospace, Broadpeak, Amagi | Play, lead with portability |
| C · Broadcast signaling | "What does policy require?" | SCTE-35/104, ESAM, POIS, ESNI / SCTE-224 | Own, our head start |
| D · Observability / proof | "Did it work, can I prove it?" | Underserved across all vendors | Own, concrete differentiator |
Small and mid-size broadcasters, FAST and niche-sports operators, and sovereignty-sensitive teams who want broadcast-grade ad insertion that runs identically on a laptop, on Linode, or on their own iron.
Margin at scale. High break volume across many low-ARPU channels means per-stream cloud cost and unfilled avails compound fast. Independence and full fill protect the spread.
Frame-accurate breaks. Tight, high-value windows where a missed SCTE marker or a late ad is lost inventory. Conformance and slate keep every break clean.
Rights enforced automatically. Blackouts and regional swaps driven by POIS policy, so the right ad airs in the right market without manual glue.
Your data, your iron. Run the whole control plane on infrastructure you control, with no viewer or signaling data leaving your boundary.
Maximum compatibility is a hard product constraint. Every output is something an off-the-shelf player or ad server already understands. Each item is tagged by how far along it is.
IMPLEMENTED shipping · PROTOTYPE / MVP TARGET in progress · PLANNED / ROADMAP / ARCHITECTURE-READY ahead · PHASE 2 / PROPOSED CONCEPT on the design board
The same loop runs whether you output SSAI or SGAI: signal in, decision and policy, conditioned ad, rendered break, and a receipt at the end.
A player hits POST /session with channel + targeting. It gets back an HMAC-signed manifest URL. Session state lives behind a SessionStore trait, never in a cloud primitive.
The origin manifest is parsed, SCTE-35 cues become avails, POIS policy applies (blackout / regionalization), and the AdDecider resolves a pod from VAST/VMAP, behind a timeout with slate fallback.
Creative compatibility is enforced at the boundary: ads are conditioned to the content's rendition ladder by a pluggable Transcoder (ffmpeg baseline), or rejected, with slate fallback when conditioning can't complete safely.
One Renderer emits SGAI (EXT-X-DATERANGE + per-session asset-list) or SSAI (EXT-X-DISCONTINUITY stitched segments), selected per session. Always padded with slate.
Impressions and quartiles fire through a BeaconSink (retry + dedup). Every avail leaves an audit record and Prometheus metrics, so you can prove what played.
Bring a live HLS feed with SCTE-35. We'll show you the break, stitched or via interstitials, with the audit trail.