You adopted EDA to reduce dependencies. You just traded runtime coupling for design-time coupling.
Every architecture decision is a tradeoff. Event-driven architecture trades one type of coupling for another.
I learned this the hard way on a production planning integration last year. We thought async messaging would give us independence. It didn’t.
Runtime coupling drops. Your services don’t wait on each other. Failures don’t cascade the same way. That’s real value.
But design-time coupling increases. Someone still owns the schema. Someone decides what “order_completed” means. Someone coordinates when that definition changes. Event contracts need governance. Versioning strategies need agreement before anyone writes code.
The coupling moved. It didn’t vanish.
This isn’t a failure of EDA. It’s the actual tradeoff EDA makes.
Runtime dependencies become design-time contracts. You’re not eliminating coordination - you’re shifting when it happens. Before deployment instead of during incidents.
I’d take that tradeoff every time. But only if you go in knowing you’re making it.
Where has EDA shifted complexity for your team rather than eliminating it?