The root of software complexity hides in the data model — data is the boundary
Why does every system crash trace back to an unremarkable if/else? Behind the 3 a.m. alert there is often a "do-everything field" gone wrong. This book's answer — the boundary of complexity lies in data, not service layers: reject universal fields, eliminate special cases, and guard the boundary with reconciliation and anti-corruption layers.
The Layers of Data Boundaries
Key Concepts
The God Field
A database field stuffed with multiple meanings, such as an overloaded status column.
It is the root of production incidents and python-length if/else — recognizing it is step one.
Concept Compression
Compressing business rules into precise data concepts so code expresses the business itself.
A good data model dissolves special cases; a bad one breeds branches without end.
State and Intent
Distinguishing the current state of data from the historical business intent that produced it.
Conflating the two makes a system both lose history and misjudge the present.
Trust Boundary
Clarifying which data can be trusted and which must be validated and reconciled.
Cross-system data is inherently untrusted — a blurred boundary is where financial loss begins.
Reconciliation
The anti-corruption infrastructure that periodically verifies data consistency across systems.
It turns invisible data decay into discoverable differences — the long-term guardian.
Map of the Book
Part One: Architecture Philosophy -- The Cost of Reuse
Part Two: Micro Unpacking -- Restructuring Fields and Dimensions
Part Three: Meso Unpacking -- Table Structures and Spacetime Separation
Part Four: Macro Unpacking -- System Boundaries and Reconciliation
Part Five: Action Guide -- Governing Legacy Systems
After reading, you will understand
- The root of incidents lies in the data model, not service layering
- God fields are the number one source of complexity
- Separate current state from historical intent
- Cross-system data is untrusted — defend the boundary with reconciliation
- Anti-corruption mechanisms keep refactoring gains from decaying