Trigpoint
The record of changes and the current state: one is the fact, the other is computed from it.

Event sourcing

Event Sourcing · Fowler (2005)
Checked against the sources ✓ Software architecture · facts and derivations Read first: Single source of truth (concept history) Tell the editor privately ▸
In three sentences Store every change as one immutable event, and obtain the current state by replaying that sequence. What things look like now stops being something you keep and becomes something you compute. The price is that you may never go back and edit the earlier entries.

↳ Seen a counter-example?

Holds when
When a record must support auditing, rebuilding any past point in time, or going back to correct an earlier entry.
Evidence
Conceptual framework; Checked against the sources
Breaks down when
Without a need for audit or look-back it costs more than it returns; and if writes are uncontrolled, it cannot support an audit.
Event sourcing Fowler (2005) Overwriting loses the history; appending keeps it Overwriting: only the present is stored State v1 State v2 State v3 the first two were overwritten, unrecoverable Event sourcing: appended one by one Event 1 Event 2 Event 3 append only replay Current state (derived) Difficulty one: replay needs snapshots a snapshot accelerates, it deletes nothing Difficulty two: outside effects replay means re-reading existing facts not running them again Figure: trigpoint.pub
Figure 1 · The upper half is the approach that stores only current state: each change overwrites the last, and the history goes with it. The lower half is event sourcing: changes stack up one by one and are never altered in place, current state is obtained by replay, and any past point can therefore be rebuilt. Two difficulties the original discusses are marked on the right: rebuilding gets slow when there are many events and needs snapshots, and outside effects must not be sent again during replay. The sequence is conceptual, with no time scale, event counts or measured numbers. View full size ▸

1. What happened

The record of changes and the state at this moment are two different things: the second can be replayed from the first, and the first cannot be recovered from the second. Most systems store current state only: a record changes and the new value overwrites the old. That approach carries a quiet loss. The history of changes vanishes permanently at the moment it is overwritten. You have how things look now, and nothing about how they came to look that way. Three things become impossible at once: auditing, rebuilding any past point in time, and going back to correct an earlier error.

Event sourcing inverts the order: the sequence of events is the fact, and current state is derived from it. The original defines it as capturing every change to application state as a sequence of events[1]Fowler, M. (2005-12-12). Event Sourcing. martinfowler.com/eaaDev/EventSourcing.html. Claims matched against the full text. The original defines it as capturing all changes to an application state as a sequence of events. The same page discusses several practical difficulties: rebuilding from scratch is slow when there are many events, so a snapshot can be stored instead; an event recorded wrongly can be reversed together with the events after it, and the corrected event replayed; and outside systems cannot tell real processing from replay, so they have to be handled through a gateway.. In practice there are only two hard rules: events are appended and never modified in place, and current state is obtained by replaying all events from empty. Once those two hold, time travel comes free: replay to the kth entry and you have how things looked at that point.

The original also discusses several practical difficulties, and three of them teach more than the definition does[1]Fowler, M. (2005-12-12). Event Sourcing. martinfowler.com/eaaDev/EventSourcing.html. Claims matched against the full text. The original defines it as capturing all changes to an application state as a sequence of events. The same page discusses several practical difficulties: rebuilding from scratch is slow when there are many events, so a snapshot can be stored instead; an event recorded wrongly can be reversed together with the events after it, and the corrected event replayed; and outside systems cannot tell real processing from replay, so they have to be handled through a gateway.. First, rebuilding from scratch gets slow when there are many events, so you need snapshots: store the state at some point and replay forward from there. Second, when an earlier event turns out to be wrong, the original's approach is to reverse it and the events after it, then replay with the corrected event; reversal is easiest when an event is written as a difference (add 10 rather than set to 110).

Third, and this is where things go wrong most: if processing an event triggers an effect outside the system (sending a letter, taking a payment), then replay cannot actually run it again, or you charge twice and the result stops being reproducible. The semantics of replay must be reading existing facts again, not running the thing again.

2. Why this matters to you

The thing in your workflow closest to this pattern is your record of decisions.

Most people hold their criteria in overwrite mode: the rule changed, so delete the old sentence and write the new one. A year later you hold a set of rules that looks very clean, and zero entries explaining how it came to be that way. This is fine while you remember. It leaves you with no material at all the moment you have forgotten, or need to convince someone else, or need to judge whether the reason behind a rule still holds.

The event sourcing move is this: the page of rules is a derivation, and the entry-by-entry record of changes is the fact. When you change a rule you append an entry (what changed, why, what triggered it), and the derived page is regenerated. A year later you have two things: a readable current value, and a traceable provenance. Before you start, choose: keep records this way only for the things someone will later ask you to explain.

Three rules transfer directly, each adapted from the difficulties above. First, never edit an old entry. When you find you recorded something wrongly, append a correction rather than going back to fix it: allow going back to fix things and the whole record loses the only value it had. Second, add a summary layer when it gets long, and never let the summary replace the record. That is a snapshot, not a deletion.

Third, replay is not redo. You go back and read old decisions to understand the judgement of the time, not to carry it out again, and the premises of the time may no longer hold.

That third rule is easy to trip over with a model. Feed a whole run of historical decisions in and ask it to continue in this pattern, and it will very obligingly carry the expired premises along with everything else.

Verification layer · Members
The guided layer of this node is open to all readers.
Verification details and failure boundaries are for members.
US$8.25 a month on average · or subscribe monthly ▸

Lab cases Written only where there is evidence

No field record for this node yet.

Common misreadings

Page verification: Checked against the sources ✓ · Content last revised 2026-11-14

  • A common account treats event sourcing as part of command query responsibility segregation. Fowler's 2005 piece does not mention the latter anywhere. The two appear together as a result of later practitioner advocacy, not a dependency in the definition. You can use either one alone. #
  • A common account says the author invented the approach. In the original he himself gives version control systems as a common example and says he has seen strong examples in accounting systems. This site therefore marks him as recording it systematically, not as its inventor; whether the name originated with him has not been checked here. Keep the two apart. #
  • A common account treats the original as a mature piece of architecture literature. The page still carries the author's own draft notice, saying this body of writing stopped in the mid-2000s and will not be revised until he can return to it. It is often treated as the standard reference, and it declares itself a draft. #
References

How to read the source notes “Matched against the full text” means the claim was compared with the text of the source itself. Definitions as of 2026-09-20.

  1. [1] Fowler, M. (2005). Event Sourcing. martinfowler.com/eaaDev/EventSourcing.html. Published 12 December 2005 (draft status per author's own notice). ↩

↳ Is a citation wrong?

Tell me when a new shelf opens

Tell me when a new shelf opens

Shelf notices are sent only when a new shelf opens or when the reading rules change.

Trial

Tell the editor privately: a correction, a counter-example or where it applies

Submissions are read only by the editor, and nothing is published before they are handled. Once a note is handled, a summary and response written by the editor are published. No sign-up is needed, and the nickname may be left blank.

What are you submitting?
Set a public name to be credited by name ▸
Submit anonymously, without signing in

Signing in lets you follow the status on your page. What you have written is kept.

You are signed in: this note is linked to your account, visible only to you and the editor, so you can follow its status on your page. The text is never published. Full privacy policy ▸

Submit anonymously instead, not linked to your account ▸

No email is collected. Your original text and nickname are read only by the editor and are never published; the site publishes only a summary the editor writes. The human check is provided by Cloudflare Turnstile. To limit abuse, the system keeps a hash of your IP address, not the address itself. Your original text is stored with our cloud provider and can be deleted on request. Full privacy policy ▸