Standards
7 min

How to Build a Taxonomy

Key takeaways

  • Start from the terms that caused arguments, not from mapping the domain.
  • Leave contested branches flat. Imposing structure hides a disagreement inside something that looks authoritative.
  • A vocabulary one system actually calls beats a complete one nobody consumes.
  • Decay is predictable and a named owner plus a quarterly review is the only reliable defence.
In this article
Share

Where do you actually start?

Most advice on how to build a taxonomy starts with the domain. Map the subject area, decompose it into categories, fill in the terms. That order is the reason so many taxonomy projects deliver something nobody uses.

Start with the arguments instead.

The instinct on a taxonomy project is to map the whole subject area first, because that feels like the responsible order. It produces a structure that is complete, unused and out of date within two quarters, because nothing in it was attached to a decision anybody was waiting on.

The alternative costs a week. List the terms that caused a disagreement in the last quarter: the ones that came up in a meeting, split a report, or made two teams produce different numbers. In most organizations that list runs to tens of items. That list is your first taxonomy.

What are the steps?

Six, and the order matters more than the thoroughness of any one of them.

StepWhat you produceDone when
1. Collect the contested termsA flat list, no structureThree people recognise their own argument in it
2. Find the real labelsWhat each term is called by each teamEvery alternative name is captured, none discarded
3. Get a decision per termOne agreed definition, with a named approverSomebody with standing has said yes, in writing
4. Add structure only where agreedBroader and narrower, where uncontestedContested branches are still flat, deliberately
5. Make it resolvableAn interface a system can callOne real system is calling it
6. Name who maintains itAn owner per branch and a review cadenceThe next change has a route that does not involve you

Step four is the one people skip past and it is the cheapest safeguard in the list. Leaving a contested branch flat makes the disagreement visible. Imposing a structure on it hides the disagreement inside a hierarchy that looks authoritative and is not.

How do you get a definition agreed?

The failure here is almost never that people disagree violently. It is that nobody is asked to decide, so the term stays ambiguous by default and everyone keeps their own version.

What makes a definition session work

  • Bring a draft, never a blank page. People correct a proposal far faster than they author one.
  • One term at a time, with the people who actually use it. Large workshops produce consensus on nothing.
  • Record the disagreement alongside the outcome. The next person to ask will ask the same question.
  • Name the approver before the session, so the meeting ends in a decision instead of a follow-up.

Where two teams genuinely need different definitions, say so explicitly and scope each one. "Active customer" can mean different things to finance and to sales, and the honest structure records two scoped terms with a note on each. Forcing one definition on an organization that needs two is how a taxonomy loses the people it was built for.

How much structure is enough?

Less than feels right. A shallow tree with good alternative labels beats a deep one nobody applies consistently, because depth forces taggers to decide how far down to go and they answer differently.

Two or three levels handles most domains. Where a concept genuinely sits under two parents, allow it and record why. Polyhierarchy covers when that is honest, and hierarchical vs faceted covers whether the thing you are modelling wants a tree at all.

The test for adding a level: can you state what question that level answers for a reader? If the answer is that it makes the structure look more complete, leave it out.

How do you make systems actually use it?

This is where most taxonomy projects quietly end. A vocabulary gets agreed, published to a portal, and every system carries on with its own local list.

What "usable" requires

  • An API that systems call. A document is a record. A system has to resolve a term at query time without a person in the loop.
  • Stable identifiers. Consuming systems point at an identifier, so a label change does not break them.
  • A versioned view. A downstream system should be able to say which agreed version it is reading.
  • A retirement path. When a term goes, the old identifier still resolves to its replacement.

Expressing the vocabulary in an open standard covers most of this for free. SKOS gives you identifiers, labels and the retirement pointer, and it means the vocabulary survives the platform it was authored in.

What should the first one be?

Pick a term that has cost somebody time this quarter, and pick a small one.

The temptation is to start with the most important term in the business, because that is where the value is. It is also where the politics are, so the pilot becomes a negotiation and proves nothing about whether the method works.

What makes a good first term

  • It has caused a visible argument. Somebody will recognise the problem when you solve it.
  • It has an obvious owner. One person can settle it without convening anyone.
  • One system consumes it. You can prove the whole path from decision to resolution.
  • It is not strategically loaded. Save the head term for after the method is trusted.

Run that one term all the way through: decide it, record it, publish it, get the system calling it. A week, maybe two. What you are proving is not the definition. You are proving that a decision can travel from the person who holds it to the system that needs it, which is the thing most organizations have never actually done.

What keeps it from decaying?

A named owner and a scheduled review, and nothing else reliably works.

The decay is predictable. A term is added without approval because the approval loop was slow. Two near-duplicate terms appear because nobody checked. A branch goes stale because the team that owned it reorganised and ownership was never reassigned. None of these are dramatic, and together they return the vocabulary to the state that justified the project.

The cheapest defence is a quarterly pass that asks three questions per branch: is the owner still here, has anything been added without approval, and is anything in here now wrong. Taxonomy governance covers the fuller model.

So what should I take away?

Build from the arguments, decide one term at a time, structure only what is agreed, and get one real system resolving it before you widen the scope. A vocabulary that one system actually calls is worth more than a complete one nobody consumes.

TopQuadrant's view is that the modelling is the easy part and the deciding is the work. The reason taxonomy projects stall is rarely that the structure was hard. It is that nobody was asked to settle the terms, or nobody with standing was available to. Design the process around getting decisions, and the structure follows. Taxonomy management covers the discipline that holds it together.

Give your AI the context it's been missing

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