Why Atomicity Matters
How far an artifact sits from the irreducible — and why that governs what may depend on it
Two artifacts. Both committed. Both true. Both backed by a named authority.
The first: OrderSubmitted { orderId } — a single customer, committing to a single order, at a single moment. The second: a quarterly regulatory report — committed, signed, authoritative, aggregating millions of transactions across dozens of accounts into a few summary figures.
Both are commit captures. Neither is more “committed” than the other. And yet they could not be more different in how they behave over time and in what may safely be built on them. The order event’s shape has not changed in a decade and never will, because what it means to submit an order does not change. The report’s shape changes every time a regulation is amended, a product line is added, or the reporting hierarchy is reorganised.
That difference is not about commitment and not about the strength of any claim. It is a second, independent facet: atomicity — how far an artifact sits from the irreducible decisions and observations beneath it. The Moment of Commitment defined the commitment boundary as capture-mode crossing — pre-bind material becoming a commit capture — without naming depth. Here we introduce the full four-level spectrum.
The four levels
Atomicity runs on a spectrum, from irreducibly atomic to heavily rendered. Four levels name the useful points along it.
Level 0 — atomic. A single decision by a single authority, or a single measurement by a single instrument, at a single moment. XRayOrdered. SWIFTPaymentReceived. OrderSubmitted { orderId }. Irreducible: it cannot be decomposed into prior events of the same kind. This is the substrate — tier one — given structural form.
Level 1 — invariant aggregate. A committed aggregate over a single ordered stream of atomic events about a single subject, maintained by a single writer. The balance after a specific transaction. All bookings for one account. Level 1 exists to enforce an invariant — balance >= 0, capacity not exceeded — and that is why it demands three structural properties, not as preferences but as conditions of correctness: strict ordering, a single stream, and a single writer. This is exactly the machinery of One Authority Per Invariant. Without those three, what looks like a Level 1 aggregate is really a Level 2 projection that may have seen an incomplete or reordered history.
Level 2 — compound aggregate. A combination across multiple streams or subjects, or a multi-step transformation. A customer summary spanning account types. A regulatory report across many ledger entries. No longer irreducible; it embeds choices about what to combine and how.
Level 3 — rendered. Optimised for human consumption: dashboards, reports, documents. The signed order PDF. The most aggregated, the most shaped by presentation decisions.
Why it matters: schema stability and contract volatility
The first reason atomicity matters is the one the opening example pointed at. The deeper the aggregation, the more directions change can arrive from.
An atomic event schema captures an irreducible truth, so its shape is governed only by that truth. XRayOrdered { orderId, physicianId, orderedAt, patientId, clinicalReason } changes only if what it means to order an X-ray changes — which is to say, almost never. It is indifferent to a new billing system, a reorganised department, a fresh reporting requirement.
An aggregate schema, by contrast, embeds design decisions, and design decisions change with requirements. A report shaped for a regulator changes when the regulation changes. A customer summary shaped for a dashboard changes when the dashboard’s consumers want a new field. Each added field is some consumer’s current appetite, and appetites move.
This is not a small matter. Schema instability is the dominant hidden cost in most software organisations — not writing new code, but migrating schemas that other systems depend on, renegotiating contracts between teams, debugging the inconsistencies that surface during every transition. Atomic schemas are nearly free of this cost because they almost never change. Aggregate schemas carry most of it. And crucially, change flows downward — from world to atom to aggregate to rendering — and never needs to flow back up: a new reporting need adds a new aggregate, it does not reshape the atomic events beneath.
Why it matters: what may depend on what
The second reason is about dependency. How far an artifact sits from the atoms governs what may safely be built on it — independently of how strong the underlying claim is.
An atomic event is its own explanation. It happened; the fact is complete; understanding it requires nothing else. A compound aggregate is only as trustworthy as the chain that produced it, and understanding it means tracing that chain — the committed balance back to the ledger entry, the ledger entry back to the originating payment. The chain can be intact and sound, but it has to be explicitly maintained, and every step is a place where detail was discarded and a design decision was made.
This is why a decision that enforces a hard invariant cannot lean on a deep aggregate, no matter how recent or accurate it looks: too much has been combined and compressed between the atoms and the figure on the screen. The further from the atoms, the weaker the claim on ground truth — a point the formal article at the end of this part makes exact.
Atomicity is independent of the other facets
It is tempting to collapse atomicity into commitment, or into tier. Resist it; they vary independently, and the independence is the whole point.
Atomicity is independent of commitment status. A heavily rendered Level 3 document can be fully committed — the signed order PDF, authoritative and permanent. An atomic Level 0 reading can be entirely uncommitted — a sensor value consumed and discarded without ever being committed to the record. Depth and accountability are different questions.
Atomicity is independent of tier. A tier-3 empirical fact can be stored as an atomic event or rendered into a glossy Level 3 chart; rendering it does not weaken the claim, and atomising it does not strengthen it. Tier is about evidential strength of the proposition; atomicity is about structural role in the architecture. A radiologist’s tier-10 read and a customer’s near-certain tier-2-by-definition order submission can both be Level 0 atomic events.
These facets are orthogonal axes, not points on one scale. An artifact has a tier and a commitment status and an atomicity level, and you need all of them to know what you are holding.
Still not enough
Atomicity adds a great deal. Combined with commitment status, it answers what kind of thing is this, and what may structurally depend on it? But it still leaves a gap, and the gap is easy to demonstrate.
Take two artifacts identical on every facet so far: both committed, both Level 1 invariant aggregates, both backed by a single writer, both carrying claims of the same tier. One is a balance updated in real time as each transaction arrives. The other is a balance updated once a night. On commitment, atomicity, and tier they are indistinguishable. For a decision that depends on the current position of the account, they are not remotely equivalent — one is current, the other may be twenty-three hours stale.
Nothing we have named yet captures that difference. It is a third facet — how confidently this artifact reflects the truth at the moment you actually use it — and it is where the next article goes.