Skip to content

When CQRS and Event Sourcing Are Too Much

For most systems, CRUD is enough. CQRS and Event Sourcing only pay off under clear conditions – this article offers an honest decision guide instead of patterns for their own sake.

≈ 10 min readSoftwareArchitecture

When CQRS and Event Sourcing Are Too Much

Changing an email address takes three lines in a CRUD handler: load, set the field, save. With CQRS and Event Sourcing, it takes five parts – a command, an event, an aggregate with a replay path, an append to the event store and a projection that updates the read model. On top of that comes a time window in which a query still returns the old address. Five moving parts and a consistency problem that didn’t exist before.

You can pay this price, and under certain conditions it pays off. I like both patterns and have defended them in other articles. For the majority of systems, they’re still too much.

This isn’t a bold claim. Martin Fowler puts it almost identically: “For most systems CQRS adds risky complexity.” And unusually clearly for him: in the majority of cases he came across, CQRS wasn’t a good choice but carried a considerable risk of getting the system into serious difficulties. When the author who made a pattern well known warns like that, an honest decision guide is worth it.

The baseline is CRUD#

Before I talk about alternatives, I want to state what the standard solution actually achieves. CRUD means: a single data model for reading and writing, direct persistence of the current state, usually against a table through an ORM. Create, Read, Update, Delete. Fowler puts it soberly: “Many systems do fit a CRUD mental model, and so should be done in that style.”

The key point is that CRUD isn’t the primitive preliminary stage you later replace with something better. For a form that gets saved and displayed again, CRUD isn’t the compromise but the right answer. An illustrative handler for it is unspectacular – and that’s exactly its strength:

async function updateCustomerEmail(id: string, email: string): Promise<void> {
  const customer = await repo.findById(id);
  customer.email = email;
  await repo.save(customer); // read and write share the same model
}

One model, one access, no latency between writing and reading. If you optimize this value away without having a problem, you trade simplicity for complexity and get nothing back for it.

What CQRS and Event Sourcing really are#

To make the decision clean, I separate the two terms that are often mentioned in one breath. CQRS – Command Query Responsibility Segregation – means you use a different model for changing data than for reading it. The write side accepts commands, checks invariants and returns nothing. The read side answers queries, returns data and changes nothing. That’s more than Bertrand Meyer’s Command Query Separation principle: CQS separates methods on an object, CQRS separates entire models.

Event Sourcing is something else. Here, every state change is recorded as an event, and the current state comes from replaying the events. The event store is the authoritative source of truth; the state is purely derived. Fowler’s analogy for this is version control: the commit log corresponds to the event store, the working tree to the current system state. I developed this idea in more detail in Event Sourcing: The Event Store as a Logbook.

Important for today’s article: the two patterns are independent of each other. Greg Young makes this clear several times – CQRS isn’t Event Sourcing, doesn’t need a message bus and isn’t necessarily tied to DDD either. You can run CQRS without Event Sourcing, that is, with a separate read database but classic state persistence. And you can run Event Sourcing with only one model. So if you introduce both together, you’re choosing two cost blocks, not one.

The costs you rarely plan for#

Separate models effectively force eventual consistency. As soon as the write side produces an event and the read side only then builds a projection from it, there’s a time window in which a query doesn’t yet see the value that was just written. Fowler says so openly: separate models increase the likelihood of having to use eventual consistency. That isn’t a feature but a cost item.

An illustrative contrast to the CRUD handler above shows the additional moving parts. First the messages:

interface ChangeEmail {
  type: "ChangeEmail";
  id: string;
  email: string;
}

interface EmailChanged {
  type: "EmailChanged";
  id: string;
  email: string;
  version: number;
}

Then the write model, which is rehydrated from its events and checks an invariant when changing instead of simply overwriting a field:

class Customer {
  private constructor(
    private readonly id: string,
    private email: string,
    private version: number,
  ) {}

  static empty(): Customer {
    return new Customer("", "", 0);
  }

  static from(events: EmailChanged[]): Customer {
    // fold the event stream into current state (replay)
    return events.reduce(
      (state, event) => state.apply(event),
      Customer.empty(),
    );
  }

  private apply(event: EmailChanged): Customer {
    return new Customer(event.id, event.email, event.version);
  }

  changeEmail(email: string): EmailChanged[] {
    if (email === this.email) return []; // no change, no event
    return [{ type: "EmailChanged", id: this.id, email, version: this.version + 1 }];
  }
}

And finally the handler, which loads, decides, appends – and updates the projection separately:

async function handle(command: ChangeEmail): Promise<void> {
  const events = await store.load(command.id);
  const customer = Customer.from(events);
  const newEvents = customer.changeEmail(command.email);
  await store.append(command.id, newEvents); // source of truth
  // read model is updated asynchronously by a projection
}

The read side is its own, deliberately dumb read model built from the same events:

class CustomerListView {
  private rows = new Map<string, { id: string; email: string }>();

  on(event: EmailChanged): void {
    this.rows.set(event.id, { id: event.id, email: event.email });
  }

  // a query right after append may still return the previous email (stale read)
  find(id: string) {
    return this.rows.get(id);
  }
}

Between the first CRUD example and this variant lies not progress but a trade-off. I’ve exchanged more types, more indirection, a replay path, a projection and a consistency window – for a benefit that only arises under certain conditions in the first place.

Beyond that, Event Sourcing brings its own, often underestimated costs. Old events have to remain readable practically forever, which makes event versioning and schema evolution a permanent task. Projections and read models have to be buildable and rebuildable. External side effects during replay need careful handling, otherwise a rebuild accidentally sends real emails. And a simple ad hoc query on the current state no longer comes for free. These points come on top of the CQRS costs.

A decision flow#

I base the decision on a few questions, in this order. Important: this applies per bounded context, not globally. Greg Young is unambiguous here – CQRS isn’t a top-level pattern; it’s applied within a component, not slapped over the entire system.

flowchart TD
  Start([New context]) --> Inv{Real domain model<br/>with colliding invariants?}
  Inv -->|no| Crud[CRUD is enough]
  Inv -->|yes| Asym{Strong read/write asymmetry<br/>OR audit/time-travel requirement?}
  Asym -->|no| Lite[Stay with CRUD<br/>or CQRS-lite]
  Asym -->|yes| Team{Can the team handle eventual consistency<br/>and event versioning?}
  Team -->|no| Kompromiss[CRUD or compromise]
  Team -->|yes| Cqrs[CQRS – plus Event Sourcing<br/>if audit or temporal]

The benefit of CQRS is closely tied to two conditions. First, a complex domain in which a shared model for reading and writing actually becomes too complicated. Second, a pronounced read/write asymmetry – many reads, few writes – so that scaling the read and write sides independently pays off. If both are missing, Fowler’s observation leads straight into the trap: CQRS on a domain that doesn’t fit increases complexity, lowers productivity and raises risk. The pattern doesn’t simplify on its own, only where real model or invariant complexity already exists.

Signals for and against#

In a concrete project, the answer hinges on a few signals that you usually see earlier than you take them seriously.

In favor:

  • a task-based UI with many people working concurrently whose actions can collide in the domain
  • hard audit, compliance or time-travel requirements that demand a complete history – this is where Event Sourcing in particular pulls its weight
  • a pronounced read/write asymmetry with separate scaling goals
  • a rich domain with real, competing invariants and clearly different read and write shapes

Against:

  • a classic CRUD or form application without real invariant complexity
  • a small team that has no experience with eventual consistency yet
  • no audit or history requirement that justifies the effort
  • the wish for a global one-size-fits-all architecture – or simply “because everyone does it”

The last point leads to the actual pitfall.

The pitfall: the pattern for its own sake#

The biggest risk isn’t the wrong technology but the wrong motivation. Greg Young describes the core precisely: teams want to implement CQRS and Event Sourcing everywhere, as a cookie-cutter architecture – and that’s exactly a massive risk. A pattern gets introduced because it shines, not because a concrete problem calls for it. Fowler advises caution because the pattern is hard to use well.

Three symptoms give away the cargo cult. There are events, but nobody can name a domain invariant they protect. There’s a projection, but the read shape is identical to the write shape. And there’s an event store, but no requirement for audit or history. When these three things come together, the pattern is decorative, not load-bearing.

Then there are the usual confusions. CQRS isn’t Event Sourcing – the two are orthogonal and can be used separately. CQRS isn’t an architecture or a top-level pattern but a decision within a bounded context. CQRS isn’t CQS, because it separates models, not methods. CQRS needs neither a message bus nor DDD. And Event Sourcing isn’t the same as event-driven integration via pub/sub – it’s an internal persistence and source-of-truth mechanism, not a communication style between systems. Fowler deliberately separates these meanings of “event-driven,” because otherwise four different things blur under one word.

More moving parts, made visible#

A direct contrast of the paths makes the trade-off tangible. The CRUD path is short; the CQRS path with Event Sourcing has more stations – and each station is a place where something can go wrong.

flowchart LR
  subgraph CRUD
    C1[Client] --> H1[Handler] --> DB[(Database)]
  end
  subgraph CQRS_ES
    Cmd[Command] --> Agg[Aggregate] --> ES[(Event Store)]
    ES --> Proj[Projection] --> RM[(Read Model)]
    RM --> Q[Query]
  end

This diagram isn’t selling anything. It just makes honest that the lower variant means more components, more contracts and more failure paths. If you know this price and pay it anyway because the domain is worth it, you’re making a good decision. If you pay it without getting the value in return, you’re building complexity in advance.

Conclusion#

CQRS and Event Sourcing aren’t better default architectures but targeted tools for targeted problems. The honest starting point is CRUD, and for the majority of systems it remains the right answer. The two patterns pay off when a domain has real, colliding invariants, when read and write load diverge strongly or when audit and time-travel requirements demand a complete history – and when the team is ready to carry eventual consistency and event versioning. They become overhead in simple CRUD apps, in small teams, without real invariant complexity and whenever the pattern is chosen out of fashion rather than need.

The best way to handle this is a conscious, context-local decision. Not globally, not as a cookie cutter, but per bounded context, with a clear “what for.” I described why CQRS needs this domain boundary and isn’t a framework in CQRS Is a Domain Boundary. The most mature architectural quality often shows not in using a demanding pattern – but in deliberately, and for good reason, not using it.

Further reading#

The sources anchor the terms against established standards. The actual message remains the context-local decision to use the pattern only where the domain deserves it.

Revised and translated from German with the help of AI.