Event-Driven Integration
Event-driven integration is an architecture in which systems publish business events — 'order placed,' 'shipment delayed,' 'payment received' — the moment they happen, and any interested system reacts immediately. It replaces the nightly batch job with a real-time nervous system for the enterprise.
The Hidden Cost of Batch
Batch integration feels safe, but its costs are just invisible until you name them:
Latency is Damage
A stock-out discovered at the nightly sync is a day of overselling. A fraud signal processed in tomorrow's batch is money already gone.
Global Collisions
Batch windows collide with global business. There is no "night" when you sell across time zones.
All-or-Nothing Failures
One malformed record can fail a file of fifty thousand, and recovery means re-running everything.
Core Patterns (and Their Traps)
Publish/Subscribe
Producers emit events; consumers subscribe. Adding consumer #7 is a zero-risk change. Trap: treating events as commands instead of facts.
Event Carried State Transfer
The event carries the data consumers need. Trap: bloated events that leak internal models. Design event schemas as versioned contracts.
Outbox Pattern
Write DB changes and events in one transaction, relay publishes. Guarantees you never save an order but lose its event.
Idempotent Consumers
Delivery is at-least-once in any real broker; consumers must handle duplicates gracefully (dedupe by event ID). Every consumer, no exceptions.
Reference Architecture on Azure
Service Bus
For business-critical events needing ordering, transactions, and dead-lettering (orders, payments).
Event Hubs
For high-volume telemetry streams (IoT, clickstreams) feeding analytics and data lakes.
Event Grid
For lightweight reactive routing and fan-out to serverless event handlers.
Operability: Where EDA Lives or Dies
Asynchronous systems fail quietly if unobserved. Our production baseline requires: correlation IDs flowing through every event so a business transaction is traceable end-to-end; dead-letter queues with replay tooling as a first-class operational surface; consumer lag dashboards so slow consumers are seen; and an event catalog documenting every schema.
When Not to Go Event-Driven
Honesty builds trust: request/response questions ("what's the current price?") belong in synchronous APIs; small landscapes with few integrations may not repay the operational investment; and teams without async debugging experience should start with one well-chosen flow, not a big-bang re-architecture. EDA is a powerful tool, not a religion.
Frequently Asked Questions
How does this coexist with our batch interfaces?
Incrementally. The outbox relay can feed both: events in real time and files for legacy consumers, retiring the files consumer by consumer.
What about ordering guarantees?
Service Bus sessions provide per-key ordering (e.g., per order ID) — which is what business processes actually need; global ordering is almost never a real requirement.
Is Kafka an option on Azure?
Yes — Event Hubs speaks the Kafka protocol, and managed Kafka (Confluent) is available when the ecosystem tooling matters. We choose per workload.
Make Your Business Real-Time
Our integration architects have built event backbones for logistics, retail, and manufacturing clients. Book an event-driven architecture workshop — we'll identify your highest-value real-time flow and design it end to end.
Book Architecture Workshop