High-Performance Relay
A specialized infrastructure component optimized for extreme query efficiency. It ensures at-least-once delivery by bridging your database and message brokers with atomic transactional integrity.
Open Outbox
Atomic event delivery for distributed systems. Standardized, high‑performance, and database-native.
Engineering Reliability at Scale
Section titled “Engineering Reliability at Scale”Database-Native Scaling
Engineered for massive datasets. Optimized for constant-time query performance, allowing multiple relay instances to scale horizontally without collisions—even on tables with millions of records.
Universal Egress
Ready for any infrastructure. Features pluggable publishers for Kafka, NATS, Redis, and RabbitMQ, with a modular architecture to plug in new drivers in minutes.
Enterprise Observability
Built for modern operations. Native OpenTelemetry integration provides deep visibility into event latency and pipeline health for complex, distributed environments.
The Open Specification
Currently in Development. A language-agnostic protocol for the Outbox pattern, defining a standard for event state and claiming logic to ensure total consistency across any stack.
How it Works
Section titled “How it Works”Open Outbox Relay sits between your application database and your message infrastructure, acting as a highly-efficient bridge.
-
Atomic Claiming The Relay identifies pending events using a non-blocking “claim-and-lock” strategy. This ensures that even with multiple Relay instances running, each event is claimed by exactly one worker with zero contention, regardless of your chosen storage engine.
-
Parallel Dispatch Claimed batches are handed off to the Publishers. Whether you are using Kafka, NATS, or Redis, the Relay handles the “plumbing” of connection pooling, batching, and concurrent delivery.
-
Acknowledgement & Cleanup The Relay waits for a “Success” signal from your message broker. Only once delivery is confirmed does it update the event state to
DELIVERED, completing the atomic bridge between your database and your stream. -
Self-Healing (Lease Management) If a worker crashes mid-delivery, the ownership lease expires automatically. Another Relay instance will transparently pick up the abandoned event, guaranteeing at-least-once delivery without manual intervention.
Why Open Outbox?
Section titled “Why Open Outbox?”Don’t reinvent the wheel. Most custom outbox implementations fail when they hit high concurrency or partial network failures.
| Feature | Homegrown Scripts | Open Outbox Relay |
|---|---|---|
| Concurrency | Row-level locking / Deadlocks | Non-blocking atomic claims |
| Scaling | Single-instance bottlenecks | Multi-node horizontal scaling |
| Delivery | Best-effort | Guaranteed at-least-once |
| Observability | Basic logs | Native OpenTelemetry & Metrics |
| Retries | Hardcoded logic | Intelligent backoff state-machine |
Pluggable Ecosystem
Section titled “Pluggable Ecosystem”Open Outbox is designed to fit your existing infrastructure, not force you into a new one.
Databases
Compatible with PostgreSQL, MySQL, and MariaDB. If it supports standard SQL transactions, it supports Open Outbox.
Message Brokers
Native drivers for Kafka, NATS, and Redis Streams. Modular architecture allows for custom driver injection.
Performance by Design
Section titled “Performance by Design”Open Outbox is engineered for predictability and minimal overhead. In our reference benchmarks:
- Constant-Time Performance: Query execution remains stable and efficient even as the outbox table grows to 100M+ records.
- Horizontal Scaling: Proven coordination across multiple concurrent relay instances with zero claim collisions.
- Low-Latency Egress: Optimized for high-throughput streaming from your database to any supported message broker.
Open Outbox
The Open-Source Standard for Reliable Event-Driven Integrity. Standardizing how distributed systems handle message delivery at scale with atomicity and high performance.