One event in, the right things out, every time.
A source event fans through transforms to every destination that needs it, with retries, idempotency, and a dead-letter queue so one bad sink never drops the rest.
Drive it — emit a few events, then knock the warehouse down and watch its deliveries dead-letter while the webhook and digest never miss a beat.
One event in, the right things out.
What you just operated is one pass through this. Producers land on a single log, each event is shaped once, and the router fans a copy to every destination on its own track, so a slow or broken one is isolated, never allowed to back up the rest.
Producers land on one log. Each event is de-duplicated with an idempotency key.
Enriched, validated, and reshaped once into the record every sink expects.
The router copies each event to every subscribed destination, independently.
A sink that keeps failing parks its events, with the reason, instead of blocking.
When the sink recovers, the parked events replay in order. Nothing is lost.
Every delivery, or a safe place to wait.
Each destination gets its own attempt. A success is acknowledged and done. A failure retries with growing backoff, and only after it has genuinely given up does the event park in the dead-letter queue, with the reason, ready to replay the moment the sink is healthy again.
Retried with backoff until it delivers or dead-letters. It doesn't just vanish.
A sink can safely receive the same event twice, so a retry never double-charges or double-sends.
Dead-lettered events keep the payload and the error, so you're debugging a record, not a mystery.
The promises that make it safe to depend on.
A pipeline is only useful if you can trust it not to silently drop things. These are the guarantees we build in, not hope for.
Every event reaches every destination, retried with backoff until it does or dead-letters.
A destination can receive the same event twice safely, so retries never double-charge or double-send.
Per-key ordering so events for one entity arrive in sequence, without serializing the whole stream.
What can't be delivered is parked with its reason and replayed once the sink recovers.
A slow or failing destination is quarantined, never allowed to back up the ones that are fine.
Every event, hop, and retry is recorded, so you can prove what was delivered and when.
The easy version works on a good day. This one is built for the bad one.
Anyone can wire a source to a few destinations and watch it work while everything is up. The value is entirely in what happens when a sink goes down mid-flow: whether the rest keep delivering, whether the failed events wait safely instead of vanishing, and whether they replay cleanly when it recovers. We build the fan-out, and we build the parts you only notice when something breaks.
Events that reach every destination, or wait safely until they can.
Fan-out with at-least-once delivery, idempotency, per-key ordering, and a dead-letter queue, so one failing sink never drops or blocks the rest.