Catalog My learning Blog
Event-Driven Architecture Course: Event Sourcing and CQRS · Phase 1 · Lesson 5 · 8 min read

When Not to Use Event-Driven Architecture

On this page
  1. Learning Objective
  2. Concept Explanation
  3. Worked Example: Seat Booking, Where Eventual Consistency Is Unacceptable
  4. Real-World Examples
  5. Review Questions & Answers

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.

SignalWhy it argues against eventsBetter fit
The user must be told yes or no before proceedingRequest-reply over a broker is strictly more complex than a call that returnsDirect synchronous call
A strong invariant spans entitiesEventual consistency cannot enforce an invariant, only detect and compensate for its violationOne transaction inside one consistency boundary
One team, one deployable, low throughputThere is no cross-team or availability coupling to removeA well-factored modular monolith
Consumers need strict global orderingGlobal ordering means a single partition, which removes the ability to scale consumers outA single ordered writer, or rethink the ordering requirement
Contracts change together across servicesThis is a distributed monolith: distribution cost with monolith couplingMerge the services or fix the boundary
High fan-out, replay, buffering, or cross-team autonomy neededThese are exactly what events are forEvent-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.

JavaScript
// 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.
A decision flow for choosing between request-driven and event-driven integration, branching on whether the caller needs an immediate answer, whether a strong invariant spans entities, and whether fan-out or cross-team autonomy is actually present, ending in a hybrid design as the common answer.
A decision flow for choosing between request-driven and event-driven integration, branching on whether the caller needs an immediate answer, whether a strong invariant spans entities, and whether fan-out or cross-team autonomy is actually present, ending in a hybrid design as the common answer.

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.
Common Pitfall"Make it event-driven" is not a default, it is a trade. Before adopting it, name the specific coupling you are removing and the specific team or scaling pain it is causing. If you cannot name it, you are buying eventual consistency, a broker dependency, and distributed debugging in exchange for nothing, and a hybrid design with synchronous calls on the critical path is almost always the more honest answer.

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.