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

Event Sourcing Pitfalls: When Not to Use It

On this page
  1. Learning Objective
  2. Concept Explanation
  3. Worked Example: A Correction, and Why It Is Harder Than an UPDATE
  4. Real-World Examples
  5. Review Questions & Answers

Learning Objective

Name the specific costs that event sourcing imposes on a team regardless of implementation quality, recognize the failure patterns that recur across teams adopting it, and decide honestly whether a given system belongs in the population it helps.

Concept Explanation

Event sourcing is the most frequently over-adopted pattern in this course, and the reason is that its benefits are vivid and its costs are diffuse. The benefits demo well: complete audit history, temporal queries, retroactive analysis, projections rebuilt at will. The costs show up eighteen months later, spread across schema evolution, onboarding time, operational tooling that has to be built rather than bought, and the discovery that a surprising number of ordinary requirements have become hard.

The first recurring cost is that the query story must be built, not assumed. Every question the system needs to answer requires a projection, and every projection requires code, a checkpoint, monitoring, and a rebuild procedure. The ad hoc query that a product manager could previously have run against the database no longer exists, because the data is a stream of changes, and the answer is either a new projection or an expensive full scan. Teams routinely underestimate how much of a conventional system's value comes from being able to ask unplanned questions of a normalized database with a SQL prompt.

The second is that the model becomes very hard to change in ways the log cannot express. A boundary drawn wrongly is not a refactor away from being right: the streams already written encode the old boundary, and splitting one aggregate into two or merging two into one means either a stream rewrite, which breaks immutability and invalidates every checkpoint and snapshot, or an upcaster layer that has to reconcile the old shape forever. Compare this to a state-oriented system, where the same change is a migration script that runs once and is then forgotten.

The third is the set of requirements that turn out to be awkward. Deleting personal data conflicts with immutability and needs crypto-shredding designed in from the start rather than retrofitted. Correcting a mistake means appending a compensating event rather than fixing a value, which is correct but means every projection must handle corrections and every user-facing view must decide whether to show the corrected value, the correction, or both. Simple lookups by a non-key attribute need a projection. And a genuinely large log eventually raises storage and rebuild-time questions that have no equivalent in a system that stores only current state.

Against all of that, the population event sourcing genuinely serves is real and identifiable: domains where the history is itself the product or a regulatory obligation, financial ledgers, trading systems, insurance policy administration, healthcare records, anything with auditors; domains where temporal correctness matters, meaning decisions must be explainable in terms of what was known at the time; and domains where the business naturally thinks and speaks in events, where a domain expert describing the process uses past-tense facts without prompting. The most reliable decision rule is scope: apply event sourcing to the one or two bounded contexts where the history has genuine value, and use ordinary state storage everywhere else. It is a pattern for a subsystem, not an architecture for a company, and teams that adopt it wholesale are the ones who write the retrospective blog posts.

SignalPoints toward event sourcingPoints away from it
Regulatory or audit obligationHistory is legally required and must be completeNo audit requirement beyond ordinary logging
Value of the pastPrior states are queried by the business regularlyNobody has ever asked what a record looked like last month
Domain languageExperts describe the process as a sequence of factsExperts describe entities and their current attributes
Query needsKnown, stable, and expressible as a handful of projectionsAd hoc and exploratory, changing weekly
Team experienceAt least some prior exposure, plus appetite for the tooling costFirst distributed system, tight deadline, small team
Model stabilityAggregate boundaries are well understoodThe domain is new and boundaries are still being discovered

Worked Example: A Correction, and Why It Is Harder Than an UPDATE

Every event-sourced system eventually has to correct a recorded fact. The mechanism is sound, but the example shows exactly how much surface area a one-line UPDATE turns into.

SQL
// A conventional system corrects a wrong amount in one statement:
UPDATE payments SET amount_cents = 17700 WHERE id = 'p-441';
-- Done. History of the mistake is gone, which may or may not be acceptable.

// An event-sourced system appends. Nothing is overwritten, so both the error
// and the correction are permanently part of the record.
await store.append('payment-p441', {
  type: 'PaymentAmountCorrected',
  data: {
    previousAmountCents: 17000,
    correctedAmountCents: 17700,
    reason: 'currency_conversion_error',
    correctedBy: 'ops-user-12',
  },
}, { expectedVersion: currentVersion });

// The cost is that every consumer of this stream now has new obligations:
//
//  1. The reducer must handle PaymentAmountCorrected, or rehydration is wrong.
//  2. Every projection that summed amounts must handle it, or its totals are wrong.
//  3. Projections already built must be rebuilt, since they never saw this type.
//  4. The finance report must decide: show the corrected figure, the original,
//     or both with an annotation? That is a product decision, not a technical one.
//  5. Any downstream service that consumed the original amount needs to react.
//
// None of that is wrong. It is simply the honest price of a record that never
// forgets, and it is the work that gets underestimated at adoption time.
A balance sheet of event sourcing: the capabilities it grants on one side, and on the other the recurring costs of projection-only querying, immovable aggregate boundaries, correction handling, and erasure under privacy law, with a scoping recommendation to apply it to one bounded context.
A balance sheet of event sourcing: the capabilities it grants on one side, and on the other the recurring costs of projection-only querying, immovable aggregate boundaries, correction handling, and erasure under privacy law, with a scoping recommendation to apply it to one bounded context.

Real-World Examples

  • Greg Young, who coined the term CQRS and is among the most prominent advocates of event sourcing, has repeatedly cautioned in conference talks against applying it to a whole system, arguing that it belongs in the parts of a domain where behavior and history matter and that applying it everywhere, including to simple create-read-update-delete subsystems, imposes cost with no corresponding benefit. That warning coming from the pattern's strongest advocate is worth more than most critiques.
  • Martin Fowler's writing on event sourcing has for years included an explicit caution about the difficulty of external system interaction during replay and about the maturity cost of the pattern, and the eventual consistency and versioning problems he flags are precisely the ones teams report in practice. The repeated industry experience is not that event sourcing does not work, but that its costs land on schema evolution and tooling rather than on the initial implementation, which is why they are systematically underestimated during adoption.
Best PracticeScope event sourcing to a bounded context, never to a whole system. Apply it where history is the product, an audit trail is mandatory, or decisions must be explainable in terms of what was known at the time, and use ordinary state storage for everything else. The teams that regret adopting it are almost always the ones who applied it uniformly.

Review Questions & Answers

Because the boundary is encoded in every stream already written, not just in the current schema. A conventional system changes a boundary with a migration that transforms existing rows once and is then finished. An event-sourced system has streams whose names, versions, and concurrency semantics all assume the old boundary, and there is no supported way to retroactively reassign a past event to a different stream. The options are a stream rewrite, which breaks immutability and invalidates every snapshot, checkpoint, and downstream consumer position, or a permanent compatibility layer that translates the old shape for as long as the system lives.

The audit log is not the whole cost of the decision, it is one benefit of it. The reasoning skips the query story, since every question now needs a projection with its own code, checkpoint, monitoring, and rebuild path; the correction story, since fixing a value becomes an appended event every consumer must handle; the erasure story, since privacy law and immutability need crypto-shredding designed in from the start; and the onboarding story, since every new engineer must learn a model most have never used. If the actual requirement is an audit trail, an append-only audit table alongside conventional storage delivers it at a small fraction of the cost.

Because it predicts whether the event model will stay stable. When experts naturally speak in past-tense facts, a policy was issued, a claim was filed, a trade was settled, those facts are the real structure of the business and they rarely change, so the events written today will still make sense in five years. When experts speak only about entities and their current attributes, the events have to be invented by engineers as a translation of a state model, and invented events track the implementation rather than the domain, which means they change every time the implementation does and the log accumulates types that nobody outside the codebase can interpret.

That the benefits are concentrated and the costs are uniform. The audit history, temporal queries, and replay-driven analysis deliver real value in the handful of contexts where the past is genuinely interrogated, typically a ledger, a policy or claims engine, or a regulated workflow. The costs, which are projection maintenance, versioning discipline, correction handling, erasure mechanics, and the onboarding burden, apply equally to every context it is used in, including the user preferences table and the content management subsystem where the history is worth nothing. Scoping it keeps the benefit and pays the cost only where it buys something.