When Not to Use Event-Driven Architecture
On this page
Learning Objective
Identify the concrete signals that a workload should stay request-driven, recognize the anti-patterns that appear when events are adopted for the wrong reasons, and articulate a defensible position in a design discussion where "make it event-driven" is being proposed by default.
Concept Explanation
Every architectural pattern has a population of systems it makes better and a population it makes worse, and the second population is always larger than its advocates admit. Event-driven architecture is worth its costs when the coupling it removes is coupling you are actually suffering from. If your system is one team, one deployable, and one database, you have no cross-team coupling to remove, and introducing a broker adds an operational dependency, a new failure mode, an asynchronous mental model, and an eventual consistency window in exchange for decoupling from nobody.
The clearest counter-indication is a workflow that genuinely needs a synchronous answer. Authentication, authorization checks, payment authorization at the point of sale, seat selection, inventory decrement in a system that cannot oversell, and anything where the user must be told yes or no before they can proceed are all request-driven by nature. You can build these on events, and people do, but you end up reinventing request-reply on top of a message broker with correlation ids, timeouts, reply queues, and a state machine, which is strictly more complicated than a function call that returns a value. If the answer is needed now, ask for it directly.
The second counter-indication is a domain with strong transactional invariants that span entities. If the business rule is that total allocations must never exceed the budget, or that a double-entry ledger must always balance, those invariants are naturally enforced by a database transaction over a consistent set of rows. Splitting them across services connected by events means enforcing them through eventual reconciliation and compensation, which is not impossible but is a substantial increase in complexity that has to be justified by something. The general heuristic from domain-driven design applies well here: keep a strong invariant inside a single consistency boundary, and use events only across boundaries where the invariant does not apply.
The third is scale that does not exist. A broker is useful when fan-out, buffering, and replay matter. At low throughput with two services and one consumer, the broker is a moving part that can break, needs upgrading, needs monitoring, and adds a hop, while delivering benefits that only become visible at a scale or team size you have not reached. The related failure is what practitioners call the distributed monolith: services split apart for organizational fashion but still requiring coordinated deployment because their event contracts change together, which combines the operational cost of distribution with the coupling of a monolith and delivers the benefits of neither.
Finally, watch for events used as a disguise for a call. If a producer publishes an event and then polls for a result, or publishes an event whose name is an imperative, or requires consumers to process events in a globally ordered sequence, the system is request-driven with extra steps. The honest move in these cases is to keep the synchronous call and spend the complexity budget somewhere it buys something. A perfectly reasonable and very common architecture is a hybrid: synchronous calls on the critical path where the user needs an answer, and published events for everything downstream that does not need to block the response.
| Signal | Why it argues against events | Better fit |
|---|---|---|
| The user must be told yes or no before proceeding | Request-reply over a broker is strictly more complex than a call that returns | Direct synchronous call |
| A strong invariant spans entities | Eventual consistency cannot enforce an invariant, only detect and compensate for its violation | One transaction inside one consistency boundary |
| One team, one deployable, low throughput | There is no cross-team or availability coupling to remove | A well-factored modular monolith |
| Consumers need strict global ordering | Global ordering means a single partition, which removes the ability to scale consumers out | A single ordered writer, or rethink the ordering requirement |
| Contracts change together across services | This is a distributed monolith: distribution cost with monolith coupling | Merge the services or fix the boundary |
| High fan-out, replay, buffering, or cross-team autonomy needed | These are exactly what events are for | Event-driven is the right call |
Worked Example: Seat Booking, Where Eventual Consistency Is Unacceptable
Seat selection is a useful test case because the naive event-driven version looks clean and is wrong. The business rule, one seat sold once, is an invariant that must hold at the moment of the decision, not eventually.
// WRONG: the user is told the seat is theirs before anything has actually
// checked whether it is. Two concurrent requests both get an optimistic yes,
// and one of them will receive a cancellation email minutes later.
async function bookSeat(showId, seatId, userId) {
await broker.publish('seats.booking_requested', { showId, seatId, userId });
return { status: 'pending' }; // no answer available yet
}
// RIGHT: the invariant is enforced synchronously inside one transaction, and
// the event is published only after the decision is already a fact. Everything
// downstream that does not need to block the response still gets its event.
async function bookSeat(showId, seatId, userId) {
const tx = await db.begin();
const updated = await tx.query(
`UPDATE seats SET status = 'sold', user_id = $1
WHERE show_id = $2 AND seat_id = $3 AND status = 'available'
RETURNING seat_id`,
[userId, showId, seatId],
);
if (updated.rowCount === 0) {
await tx.rollback();
return { status: 'unavailable' }; // an immediate, truthful no
}
await tx.commit();
await broker.publish('seats.sold', { showId, seatId, userId }); // now a fact
return { status: 'confirmed' };
}
// Email, loyalty points, analytics, and the recommendation model all consume
// seats.sold asynchronously. The invariant stayed synchronous; the fan-out
// did not have to.Real-World Examples
- Amazon publicly documented in 2023 that its Prime Video audio and video quality monitoring team moved from a distributed serverless architecture using AWS Step Functions and S3 for intermediate state back to a single consolidated process, reporting a roughly 90 percent reduction in infrastructure cost. The published analysis attributes the cost to orchestration transitions and the volume of intermediate data shuttled between components, a concrete case of a distributed, message-passing design being the wrong tool for a tightly coupled, high-frequency pipeline that fit comfortably in one process.
- Shopify has written publicly about deliberately running a modular monolith for its core commerce application rather than decomposing it into microservices, describing an internal component boundary enforcement approach instead. Their stated reasoning matches this lesson directly: they wanted the boundary clarity that decomposition promises without paying the distributed-systems cost, and they concluded the coupling worth removing could be removed inside a single deployable.
Review Questions & Answers
Because the resulting system has all the machinery of a synchronous call, a correlation id, a reply destination, a timeout, and a caller blocked waiting for an answer, plus the broker as an extra hop and an extra failure mode, and none of the benefits events were adopted for. The producer is once again coupled to the availability and latency of the consumer, since it cannot proceed without the reply. If the answer is needed synchronously, a direct call expresses that requirement more clearly, fails more clearly, and traces more clearly.
A distributed monolith is a system split into independently deployed services that nonetheless cannot be deployed independently, so it pays the operational and debugging cost of distribution while retaining the coupling of a monolith. The most reliable symptom is coordinated release: if changing an event schema or an interface in one service requires a matched deploy of two or three others in a specific order, the boundary is wrong. Independent deployability, not the existence of a broker or a service count, is the property that determines whether decomposition actually bought anything.
Because eventual consistency cannot enforce an invariant; it can only detect that one has been violated and compensate afterwards. If two users are told their seat booking is pending and only one can actually have the seat, the system has already made a promise it must later break, which means a cancellation email, a refund, and a bad experience for a real customer. Enforcing the constraint synchronously inside one transaction converts that later apology into an immediate, truthful no. Latency and throughput are performance concerns; this is a correctness concern, which ranks higher.
Which specific coupling is causing pain today, and to whom? Are teams currently blocked waiting on each other to deploy? Is a downstream outage currently taking down an upstream service? Is there real fan-out, meaning more than one consumer of the same data, or is this one-to-one? Does any call in scope need a synchronous answer for the user? And who will own the broker, the schema registry, the consumer lag alerting, and the dead letter queue triage? If the answers are that nothing is blocked, fan-out is one-to-one, and nobody has budget to operate the new infrastructure, the proposal is buying costs without benefits.