How an open standard stays neutral when a vendor funds it

Here’s the fair, skeptical question this project has to answer: why trust a “neutral” data standard if a vendor funds it? It’s the right question to ask, and the honest answer is that neutrality has to be built and demonstrated, not asserted. Funding pays for the work; governance decides what the standard becomes, and keeping those two separate is the whole game. This post lays out the mechanisms, and how you can check them yourself.

Can a vendor-funded standard actually be neutral?

Yes, but only if specific things are true, not just said. There’s real precedent: open standards have long been funded by companies that also sell products built on them, and they stay credible because of how they’re governed, not because anyone takes the funder’s word for it. The test isn’t “is there a sponsor?” It’s “can the sponsor change the standard to favor itself, and can a competitor adopt it freely?”

The four mechanisms that keep it honest

1. Governance is a firewall

The standard is governed in the open, by multiple stakeholders, with decisions visible. A sponsor funds the work but is one voice among others, and it can’t unilaterally reshape the standard to suit its product. The funding and the control are deliberately separated.

2. Conformance, not capture

Anyone can build to the standard and claim conformance, including the funder’s competitors. This is the strongest possible proof of neutrality, and it’s structural:

If the standard were secretly tilted, a competitor couldn’t build to it cleanly. The fact that they can is the test passing in public.

3. It reduces lock-in away from the funder, too

Because your data maps to a neutral spine, you can leave any implementation (including the sponsor’s) as easily as any other (the portability drill is how you’d verify it). A funder betting on a standard that makes its own product easy to leave is betting on being good, not on being sticky. That’s the opposite of lock-in.

4. Eat your own cooking, in the open

A sponsor building its own products on the same open standard is a feature, not a conflict: it’s a working proof that the model holds under real load. What matters is that the standard, the governance, and the conformance definition are public, so the proof is checkable rather than asserted.

The honest part: it has to be demonstrated

We won’t pretend this is finished. The single biggest risk to any commons is a one-funder commons: neutrality asserted by a standard only one organization stands behind. It becomes real as more contributors and sponsors join, as governance operates visibly over time, and on the day a competitor conforms publicly. We said as much in one year in, and it remains the thing to hold us to. Who currently funds and stewards the work is disclosed openly on the sponsors page. Transparency is part of the mechanism, not a footnote.

This is why neutrality is the load-bearing property of a vendor-neutral common data model in the first place: without it, a “standard” is just one vendor’s model with better marketing.

What you get

A way to evaluate this project, or any vendor-funded standard, on evidence instead of trust: open governance you can read, conformance a competitor can earn, an exit you can test, and contributors beyond the funder. If those are real, the standard is neutral in the only way that counts. If they’re not, no amount of “we’re neutral” should convince you, and you should hold us to exactly that bar.

See who funds and stewards the commons on the sponsors page, and how the foundation works in How It Works.

The standard is open and early; treat current releases as drafts. Examples use synthetic data.