Decide Where the Truth Lives

Almost every broken system I have ever been called in to fix had the same disease underneath it. Two systems both believed they were right about the same fact, they disagreed, and nobody had decided in advance which one to trust. So the "fix" was always a person, quietly reconciling by hand, forever.

The cure is the least glamorous architectural decision there is, and it's the one that matters most: pick one place where a fact is allowed to be true. Everything else is a copy.

The Question Before All the Others

Before you connect two systems, answer one question: when they disagree, who wins?

If you can't answer it, you don't have an integration. You have a future argument. Sooner or later the two systems drift—a network blip, a half-finished update, a manual edit someone made on a Tuesday—and now you have two versions of reality and no rule for choosing between them. That's the moment the 2am pages start.

Deciding where the truth lives ends the argument before it begins. One system is authoritative. The rest defer to it. When they disagree, the source wins, every time, and nobody has to be in the room to referee.

One Database, Not Five Opinions

My card business sells across four marketplaces plus its own storefront. Five places a card can appear, and each one has an opinion about whether that card is still for sale.

I don't let any of them hold the truth. A single database knows the real state of every card—what I paid, where it's listed, whether it's sold. Every marketplace is a projection of that database, never the other way around. When a card sells anywhere, one operation records the sale against the database and delists it everywhere else. The marketplaces don't negotiate with each other. They all read from the same book.

The same shape runs the shop's finances. Sales scatter across five channels, but a fleet of jobs pulls all of them into one database and reconciles the books to zero against it. The morning email I get isn't stitched together from five dashboards—it's a read of the one source that already agrees with itself.

I Picked My First Source of Truth Years Ago

This isn't a trick I learned building commerce backends. I learned it running IT.

When I built a healthcare company's systems from nothing, the first thing I stood up wasn't a device or a dashboard—it was identity. Okta became the source of truth for who a person was, and every application and every access decision flowed through it. Fifty-plus apps didn't each keep their own private list of who worked there. They deferred to one.

That decision paid off most at the end, not the beginning. When someone left, I revoked them in one place and the access disappeared everywhere downstream. No hunting through fifty apps hoping I remembered them all. The whole point of a source of truth is that you only have to be right once.

Everything Else Is a Projection

Once you've named the authority, a lot of hard problems turn into easy ones, because they stop being separate problems.

A marketplace listing is just a view of the inventory database. A compliance dashboard is a view of the device fleet. A welcome email to a new hire is a view of the identity record that was just created. The morning finance brief is a view of the reconciled books. None of these hold anything themselves. They render what the source already knows, and if one of them goes stale, you refresh it from the source instead of trying to work out which copy was right.

That's the quiet superpower. When everything is a projection, "fix the data" always means the same thing: fix it in one place, then re-render.

Re-Derive, Don't Sync

The failure mode I design hardest against is drift—two copies slowly disagreeing while everyone assumes they match. And the thing about drift is that you can't sync your way out of it. Every clever design I tried that kept two systems in step by passing changes back and forth eventually found a way to fall out of step silently.

So I stopped syncing and started re-deriving. The jobs that keep my systems honest don't nudge state from one place to another—they throw away the copy and rebuild it from the source. A job like that can't drift, because it never trusts the copy in the first place. If it crashes, the next run makes everything right again.

Pick one place to be right. Make everything else a copy that can be rebuilt from it. Then you never have to wonder who to believe—because you decided that on day one.