Lessons from Scale

Lessons from Scale #6: Standards Don’t Fail — We Just Stop Being Honest About Them

Abandoned data falling back into nature

There’s a comforting myth we like to tell ourselves in technology:

If only everyone followed the standard, things would work.

This is almost never true. And when it is true, it’s usually long after the problem has already moved on.

Standards don’t fail because they’re poorly designed. They fail because, over time, we stop being honest about what they are and what they’re actually doing for us. We treat them as fixed truths instead of what they really are: temporary agreements between people trying to solve a very specific problem at a very specific moment.

Early on, standards work because they’re a little vague. They leave room for interpretation. They allow different teams to project their reality onto a shared shape. That ambiguity isn’t a bug—it’s the adoption strategy. It’s why things like the SpatioTemporal Asset Catalog (STAC) worked as well as they did. Not because it was perfect, but because it was permissive, practical, and just opinionated enough to be useful.

That’s the good phase.
This is when we say “ecosystem” and don’t feel weird about it.

Then scale shows up and changes the job.

At scale, a standard stops being a convenience and starts being infrastructure. People build businesses on it. Tooling hardens around it. Backward compatibility becomes sacred. Revisiting core assumptions starts to feel risky—even irresponsible.

So instead of asking whether the model still fits reality, we do the safer thing: we add extensions.

Extensions are how standards avoid conflict. Each one is someone saying, “This almost works for us.” Over time, almost quietly disappears, and we pretend this expanding pile of optional complexity was intentional. The standard hasn’t changed, we tell ourselves—it’s just flexible now.

Eventually, the schema stops being an interface and starts being treated as truth. The JSON isn’t a serialization anymore; it’s the model. Validation becomes more important than understanding. “Is it valid?” replaces “Does this help someone actually do their job?”

That’s when standards stop being engineering artifacts and start drifting toward theology.

---

Keeping the Conversation Going (via Chris Holmes)

Chris Holmes responded to this post on LinkedIn with a framing that’s been stuck in my head:
https://www.linkedin.com/posts/opencholmes_spatially-adjusted-by-james-fee-activity-7420578620508889090-wr9k

Assumptions are explicit.
Workflows are visible.
Metadata is mandatory.
Humans are no longer the glue.

He also asked whether we need a better name than “cloud-native SDI,” suggesting “Honest SDI.” I like that—not because it’s clever, but because it shifts the focus away from infrastructure and toward accountability.

Where this connects directly to the argument above is that honesty isn’t just about making assumptions explicit. It’s about admitting when the abstraction no longer fits.

Most SDI efforts don’t fail because the technology is wrong. They fail because the model freezes while workflows keep evolving. We declare victory at the schema layer and quietly let humans absorb the mismatch. Scripts. Sidecars. Tribal knowledge. Slack messages. “Oh yeah, you just have to know that part.”

That’s not interoperability.
That’s unpaid labor.

An honest SDI wouldn’t just require metadata. It would make workflows first-class. It would treat schemas as contracts that can be renegotiated, not artifacts to be defended. And it would assume—by default—that if humans are acting as glue, something upstream has already failed.

So yes, I like the name.
But more importantly, I like what it forces us to confront.

If a system only works because experienced people know where it lies, the system isn’t mature yet. It’s just scaled.

---

Closing Thought

The real failure mode isn’t fragmentation.
It’s pretending yesterday’s abstraction still fits today’s system.

If we want systems that actually scale, we need fewer sacred schemas and more honest conversations—like this one.

Let’s keep it going.