Standards
7 min

Taxonomy and Ontology Management: Running Both Together

Key takeaways

  • Teams end up with both because each arrives from a different direction and neither does the other's job.
  • The real overlap is narrow: stable identity, and a record of who agreed.
  • Broader and subclass look alike and behave differently. Importing one as the other produces unwanted inferences.
  • Build the vocabulary first. It is the conversation an organization can actually have, and it reveals the contested concepts.
In this article
Share

Why do organizations end up running both?

Taxonomy and ontology management are usually treated as one phrase and run as two programmes. Almost nobody sets out to do that. They end up with both because the two arrive from different directions and neither can do the other's job.

The taxonomy usually comes first. A team needs a controlled list of subjects, product categories or document types, and agreeing a vocabulary is the cheapest thing an organization can do together. The ontology arrives later, when somebody needs the relationships between those concepts to be enforceable instead of implied.

By the time both exist they are often owned by different teams, expressed in different tools, and describing overlapping parts of the same business. That is the operating problem this piece is about.

What each discipline is belongs elsewhere. Ontology management is the pillar on that term and this piece does not restate it. Taxonomy management covers the vocabulary side, and ontology vs taxonomy vs knowledge graph covers the conceptual difference.

Where do the two actually overlap?

Less than people expect, and the overlap is concentrated in one place.

ConcernTaxonomy sideOntology side
Concept identityA term with a stable identifierA class with a stable identifier
HierarchyBroader and narrower, for navigationSubclass, for inference
RelationshipsMappings to external schemesProperties between classes, with constraints
ApprovalWho agreed this term means thisWho agreed this rule holds

The overlap is the first row and the last. Both disciplines need stable identity and both need a record of who agreed. Everything else diverges, and that divergence is useful. The two are doing different jobs.

The row that causes the most trouble is hierarchy. Broader and subclass look alike and behave differently. A reasoner will draw conclusions from subclass that a navigational hierarchy never intended, which is how a tidy taxonomy imported wholesale into an ontology starts producing inferences nobody wanted.

What goes wrong when they are run separately?

The symptoms are consistent across organizations, and three of the four are invisible until somebody tries to use both artifacts for the same question.

Four recurring failures

  • Two identifiers for one concept. The vocabulary and the model each mint their own, and nothing resolves between them.
  • Divergent approval. A term is updated in one and not the other, and both claim to be current.
  • Hierarchy imported blindly. Broader relationships become subclass relationships and the reasoner draws conclusions the vocabulary never meant.
  • Duplicate governance. Two review boards, two cadences, and the same subject-matter expert asked the same question twice.

The last one is why these programmes lose their experts. The scarce resource in both disciplines is the handful of people who actually hold the meaning, and asking them for the same decision through two processes is the fastest way to lose their attention.

What does running them together look like?

One identity space, one approval route, two expressions.

A concept gets its identifier once. The vocabulary describes it with labels, notes and navigational hierarchy. The model describes it with properties and constraints where those are needed. Both point at the same identifier, so a question about what a concept means has one answer regardless of which artifact you asked.

What the join requires in practice

  • Shared identifiers. Minted once, never duplicated. This is the whole foundation and the part most organizations skip.
  • One approver per concept. The domain expert approves the meaning, and both artifacts inherit that decision.
  • Explicit mapping, never implicit. Where a vocabulary term corresponds to a model class, say so in the data instead of assuming matching names.
  • Separate validation. The vocabulary is checked for structure. The model is checked for constraints. Different tests, same review trail.

Open standards make the join cheap because they were designed for it. SKOS and OWL are both RDF, so a concept can carry vocabulary terms and model statements without conversion, and SHACL validates across both.

How should ownership be arranged?

One governance process, two kinds of expertise feeding it.

The common arrangement that fails is two boards. The one that works is a single review route. A proposed change carries whichever expressions it affects, and the people who need to look at it are pulled in per change instead of per discipline.

The practical test is whether a subject-matter expert is ever asked the same question twice. If they are, the processes have not joined, whatever the org chart says.

Taxonomy governance covers the vocabulary half of that review and the wider data governance frame is in data governance for AI.

Which one should you build first?

The vocabulary, almost always, and for a reason that is organizational instead of technical.

Agreeing a list of terms is a conversation most organizations can have. Agreeing a model requires the same people to also agree how concepts relate, which is a longer argument and usually a premature one. Teams that start with the model spend months in design and produce nothing anyone consumes.

Starting with the vocabulary gets something resolvable into a system within weeks, and it surfaces which concepts are genuinely contested. Those contested concepts are exactly the ones the model will need to handle carefully, so the taxonomy work is reconnaissance for the modelling work instead of a detour from it.

What does this ask of the tooling?

Less than vendors suggest, and one thing more than most products offer.

Both expressions being RDF means a single store can hold them, so the technical join is not the hard part. What is rarer is a product that treats a vocabulary term and a model class as potentially the same concept, with one identifier and one approval, instead of as records in two unrelated modules.

Questions worth asking a vendor

  • Can one concept carry both vocabulary and model statements? Or does the product force a choice at creation.
  • Is there one approval trail across both? Two review queues means two queues to the same expert.
  • Does export keep the join? A round trip that separates them has undone the work.
  • Can a consumer ask for an agreed version? Downstream systems need to pin a version while the next one is drafted.

The last one is the quiet requirement. A vocabulary and a model that move independently give a consuming system no coherent thing to read, and the usual workaround is a hand-maintained copy that goes stale immediately.

So what should I take away?

Run one identity space and one approval route, and let the vocabulary and the model be two expressions of the same agreed concepts. Build the vocabulary first. Keep broader and subclass distinct, because conflating them produces inferences nobody asked for.

TopQuadrant's position is that the join is an identity problem before it is a tooling problem. Organizations that mint one identifier per concept find the rest follows, and organizations that do not spend years reconciling two descriptions of the same business. Both expressions live in RDF, so the join costs nothing structurally. What it costs is the discipline to decide, once, what a thing is called and who says so.

Give your AI the context it's been missing

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