Standards
7 min

Open Standards vs Proprietary Graph Platforms

Key takeaways

  • Data exports from everything. Identity, semantics, constraints and provenance usually do not.
  • Proprietary platforms genuinely win on time to first result, performance on narrow shapes and operational simplicity.
  • Standards become decisive once the graph holds agreements rather than only data.
  • Test portability with an export, a diff, and a re-import into a different product. Step four is where the gaps appear.
In this article
Share

What is the real choice between open standards and proprietary graph platforms?

The choice is not about ideology, licensing or even cost. It is about one question: when you leave this platform, what comes with you?

Every graph platform stores your data and will export it. The question is what happens to the things you spent years building. The model, the constraints, the agreed definitions, the record of who agreed them. Do those leave in a form the next system can read without a translation project?

Open standards here means the W3C stack: RDF for identity and statements, OWL for semantics, SHACL for constraints, SPARQL for query. Proprietary means a vendor's own data model and query language, usually faster to start with and often genuinely good.

What actually creates lock-in?

Not the data. Data exports from everything, and a CSV of nodes and edges is easy to produce.

What does not export cleanly is everything above the data, and that is where the years went.

LayerExports cleanly?Why it matters
Nodes and edgesYes, from anythingThe easiest layer and the least of your investment
IdentityOnly if identifiers are globalLocal keys mean the next system cannot tell two records are one thing
SemanticsOnly if expressed as dataMeaning encoded in application logic stays behind
ConstraintsOnly if declarativeRules written in procedural code are a rewrite, not a migration
ProvenanceRarelyWho agreed what, and when. The hardest thing to recreate and the easiest to lose

The pattern is consistent. The parts that are cheap to rebuild export easily, and the parts that took the longest to agree are the ones most likely to be trapped.

What is the honest case for proprietary?

It is a real case and worth stating properly, because a comparison that only lists the other side's weaknesses is marketing.

Where proprietary platforms win

  • Time to first result. Opinionated tooling with one way to do things gets a team productive in days.
  • Performance on specific shapes. A vendor optimising a narrow model can beat a general one on that model.
  • Operational simplicity. One product, one support contract, one set of defaults.
  • Ecosystem depth. Drivers, integrations and a hiring pool that already knows the query language.

If the graph is an implementation detail inside one application, with a defined lifespan and no governance requirement, these advantages are decisive and portability buys you nothing. Not every graph is an enterprise asset, and treating a tactical one as though it were is its own kind of waste.

When do standards become the deciding factor?

When the graph holds agreements rather than only data.

An agreement has properties that data does not. It has an author, a date and a scope. It can be superseded, and the superseded version still has to be reachable, because somebody will eventually ask what the rule was in March. It has to mean the same thing to a system that was not built by the team that authored it.

Signals the agreement layer is in play

  • More than one system consumes it. The moment two systems read the same model, a shared format stops being optional.
  • An auditor might ask. Regulated answers need the rule and its approval, reconstructable after the fact.
  • The model outlives the project. Anything with a five-year horizon will outlive at least one platform decision.
  • Domain experts change the rules. Constraints as data can be reviewed by the people who own the meaning; constraints as code cannot.

That last point is the one that surprises teams. Declarative constraints are usually sold as a technical feature. Their real value is organizational. They move rule changes out of the engineering queue and into the hands of the people who hold the meaning.

Is there a middle path?

Yes, and it is what most large enterprises end up running.

Use a proprietary or property-graph store where the workload demands it, and hold the governed model in open standards above it. The analytical graph does what it is good at. The agreement layer stays portable. The two are connected by mappings that are themselves maintained as data.

This costs something. You are running two things and keeping the mapping current, and that mapping is a real maintenance obligation somebody has to own. The alternative is choosing one layer to compromise, and the usual compromise is to let the governed model live in the operational store, where it quietly becomes unportable.

RDF vs property graphs covers the model-level trade, and types of graphs maps where each tier sits.

What does getting it wrong actually cost?

Rarely a dramatic failure. Usually a slow one, booked under a different heading.

Where the cost lands

  • A replatform becomes a re-authoring project. The data moves in a week and the agreements take two quarters, because somebody has to reconstruct decisions from people who have since left.
  • A second system gets its own copy. When the model cannot be read by anything else, the second consumer forks it, and the two drift from that day.
  • Audit answers get assembled by hand. With no provenance in the data, answering what a rule was in March means interviewing people and reading tickets.
  • Rule changes queue behind engineering. Constraints in code mean every definitional change becomes a deployment, which is how approval latency starts climbing.

None of those appear in a procurement comparison, because all four are costs of exit and the comparison is run at entry. That asymmetry is the whole reason this choice gets made badly.

How do you test portability before you commit?

With an export and a diff, during the trial, on your own model.

The portability test

  • Build a small governed model with constraints, several labels per concept, and an approval recorded against one definition.
  • Export it in whatever format the product offers.
  • Diff the export against what you built. Count what is missing.
  • Re-import into a different product. This is the step everyone skips and the only one that proves anything.

Most products pass the first three steps and the fourth is where the gaps appear. Constraints vanish, alternative labels collapse into one, and provenance is absent entirely. None of that shows up in a demo, and all of it shows up in year four.

So what should I take away?

Lock-in is not about data. It is about whether identity, semantics, constraints and provenance can leave. Proprietary platforms are a sound choice for tactical graphs and a risky one for agreements meant to outlive the tooling.

TopQuadrant builds on the W3C stack, so this is a position we hold and benefit from. State it plainly and test it the same way. Our knowledge graph platform expresses the model and its history in RDF, OWL and SHACL, which means the agreement can leave if you decide to go elsewhere. Run the export, the diff and the re-import. On us and on everyone else.

Give your AI the context it's been missing

See how the TQ Data Foundation turns your enterprise knowledge into trusted, Al-ready context.