A million messages. Five minutes.
A durable queue, competing worker pools, atomic rate limiting, and exponential-backoff retries — engineered to absorb a million-message burst without breaking a sweat.
One API · every channel
Ingestion is decoupled from delivery. The queue absorbs the burst; workers drain it.
Every failure path is accounted for.
The hard parts of high-scale delivery — durability, fairness, retries, scale — handled at the infrastructure layer.
A queue that survives anything
Every notification is persisted to a durable RabbitMQ queue the instant it's accepted. Brokers restart, workers crash — messages are redelivered, never lost.
No recipient ever gets flooded
A single Redis Lua script enforces the per-recipient cap atomically across every worker. Over the limit? The message is deferred — not failed, not dropped.
Transient failures heal themselves
Failed sends are re-queued with an exponentially growing delay plus jitter, via per-message TTL. After the final attempt, they dead-letter exactly once.
Throughput is a dial, not a rewrite
Workers are competing consumers with fair prefetch. Add processes to add throughput — linearly, with zero code changes and zero downtime.
Launch a blast. Watch the engine work.
Synthetic recipients are generated on the fly. The failure-rate dial drives the retry and dead-letter paths — all real, all live.
$ awaiting blast…
backend offline — start the API + worker to stream live data
Boring infrastructure, used precisely.
No exotic dependencies. Proven primitives composed correctly: a broker for durability, a cache for atomic coordination, stateless workers for scale. Deploys to Render and Vercel as two units.
See it absorb a million.
Spin up a demo blast and watch throughput, retries, and rate limiting play out in real time.