
Event-driven integration gets recommended a lot and adopted badly. The pitch is genuinely good — the ERP publishes facts, anything interested subscribes, adding a consumer requires no change to the producer. The part that gets skipped is that you have just built a distributed system, and distributed systems are harder to debug than the point-to-point mess you replaced.
This post is about capturing the real benefits while limiting how much of that tax you pay.
What You Are Actually Buying
Three things, and it is worth being precise because only one of them is decoupling.
Decoupling. Add a consumer without touching the producer. Real, and the one everyone cites.
Replay. This is the underrated one. When a consumer has been writing bad records for a week, you fix the consumer and replay the window. Without an event log you reconstruct state by hand from whatever audit trails happen to exist, which in an ERP context means a reconciliation project.
An audit trail by construction. The log is the history of what changed and when. Auditors like this and it costs you nothing extra.
If none of those three are worth anything to you, do not build this. A hub-and-spoke integration platform is simpler to operate and adequate for most estates.
Getting Events Out of an ERP That Has None
Most ERPs do not emit events. Three options, in descending order of how much I like them.
Application-level outbox. If you control code in the ERP or its extension layer, write the event to an outbox table in the same transaction as the business change, and have a relay publish from that table. Atomic with the business write, no dual-write problem, and you control the event shape.
BEGIN;
UPDATE orders SET status = 'confirmed' WHERE id = 1024;
INSERT INTO event_outbox (aggregate_id, event_type, payload, version)
VALUES (1024, 'order.confirmed', '{...}', 7);
COMMIT;
Change data capture. Read the database write-ahead log and synthesise events from row changes. Works without touching the application, which is often the only option with a packaged ERP. The cost is that you are now coupled to an internal schema the vendor can change in a patch release, and your events are row-shaped rather than domain-shaped — orders row changed, not order.confirmed. You end up rebuilding domain meaning in a translation layer.
Polling. Query for records modified since a watermark and synthesise events. Crude, high latency, misses intermediate states. Occasionally the only option. If you are here, make the polling interval and the watermark explicit and monitored, because silent watermark drift is a nasty failure.
Prefer the outbox where you can get it. Accept CDC where you cannot, and budget the translation layer honestly.
Event Contracts Are Public APIs
The most common failure in event-driven estates is treating the event schema casually because it is "internal."
It is not internal. It has consumers you do not control and may not know about. Changing it breaks them, and unlike an HTTP API there is no request-response to tell you immediately.
Rules that work:
-
Additive changes only within a major version. New optional fields are fine. Removing a field, renaming one, or changing its meaning is a new version.
-
Version in the event, not just the topic. Consumers should be able to check what they received.
-
Publish a schema registry and validate on produce. Catching an invalid event at publish time is enormously cheaper than at consume time in three different services.
-
Events describe facts, not intentions.
order.confirmedis a fact.send_confirmation_emailis a command and does not belong in a shared event stream — it couples the producer to a specific consumer's behaviour.

The Consumer Rules That Save You
Idempotency is not optional. At-least-once delivery means duplicates are guaranteed. Key from the business event, store processed keys in the same transaction as the work, and retain them longer than your maximum replay window.
Tolerate out-of-order arrival. Most brokers order within a partition only. Either partition by aggregate ID so events for one entity stay ordered, or carry a version and ignore anything older than what you have applied:
UPDATE orders SET status = $2, source_version = $3
WHERE id = $1 AND source_version < $3;
Combine with upsert so an update arriving before its create simply creates the record.
One consumer, one concern. The temptation is a consumer that handles five event types and writes to three systems. It is quicker initially and it recreates the coupling you adopted events to remove.
Limiting the Debugging Tax
This is where most of the pain lands, and three things address most of it.
Correlation IDs through every hop. Generated at the origin, carried in every event, logged by every consumer. Without this, tracing one business transaction means reading five log streams and guessing at timestamps. With it, one query.
A consumer lag dashboard, per consumer per partition. Lag is your early warning system. A consumer falling behind is visible minutes before it becomes a business problem, and lag by partition tells you whether it is a hot key or a general slowdown.
A dead-letter queue with a named owner and an alert on depth. A DLQ nobody watches is a data-loss mechanism with extra steps.
Add reconciliation on top of all of it. Compare counts and totals between the ERP and each downstream system on a schedule and alert on divergence. Everything above prevents failures you anticipated; reconciliation catches the ones you did not.
When Not to Do This
If you have three systems, stable interfaces and no replay or audit requirement, event-driven is overhead. A hub-and-spoke platform handles routing, retries and transformation with far less operational surface, and the honest comparison is against that rather than against point-to-point chaos.
The other honest caveat: this works when someone owns the platform. Event infrastructure without an owner degrades into topics nobody understands, consumers nobody monitors and a log nobody trims. If you cannot name the owner, choose the simpler architecture.
Full guide — the four patterns, canonical data models, master data, idempotency, security and cost — at ERP integrations.
Frequently Asked Questions
Is change data capture a good way to get events from an ERP?
It is often the only option with a packaged ERP, and it works, but it couples you to an internal schema the vendor may change in a patch release and produces row-shaped rather than domain-shaped events. Budget for a translation layer that rebuilds domain meaning, and monitor for schema changes on the vendor side.
How do we version event schemas safely?
Additive changes only within a major version, with the version carried inside the event rather than only in the topic name. Validate against a schema registry at publish time, since catching an invalid event when it is produced is far cheaper than discovering it in three consumers. Treat a breaking change as you would a public API change.
Should events describe facts or trigger actions?
Facts. order.confirmed is a fact that any number of consumers can interpret. send_confirmation_email is a command aimed at one consumer, and putting it in a shared stream recreates exactly the coupling event-driven architecture is meant to remove.
How do we debug a business process spanning five consumers?
Generate a correlation ID at the origin, carry it in every event, and log it in every consumer. That turns a five-log-stream investigation into a single query. Add per-consumer per-partition lag dashboards so you can see a consumer falling behind before it becomes a business problem.
When is event-driven integration the wrong choice?
When you have a small, stable estate with no replay or audit requirement, and when nobody will own the platform. Event infrastructure without a named owner degrades into topics nobody understands and consumers nobody monitors. In those cases a hub-and-spoke integration platform delivers most of the value with much less operational surface.