Skip to main content

Ontology & Governance Best Practices

This page describes recommended practices for designing, scaling and governing ontologies in Timbr. It covers how to structure an ontology estate, how to model inside each ontology, who owns what, and how to manage change, testing and security as the number of ontologies grows.

The practices balance four needs that arise in every enterprise semantic-layer program:

NeedMeans
ConsistencyShared business concepts have stable, reusable definitions.
SpeedIndividual teams and use cases deliver without a central bottleneck.
AutonomyDomain teams and subject-matter experts (SMEs) evolve models close to the business.
ControlSecurity, quality, ownership and semantic changes stay governed as the estate grows.

The guiding idea is to manage ontologies the way you manage software interfaces and service contracts: keep shared models stable, isolate change where appropriate, reuse intentionally, compare versions before adopting them, test continuously, and promote proven semantics into shared models.

Guiding principle

Govern shared semantics strongly, let local semantics evolve quickly, and promote proven knowledge into shared models instead of requiring universal alignment upfront.


Structuring the ontology estate​

A stable core plus domain and use-case ontologies​

For most large implementations, the recommended pattern is one shared (core) ontology surrounded by independently governed domain and use-case ontologies:

                    ┌──────────────────────┐
│ Shared / Core │
│ Ontology │
└──────────┬───────────┘
│
reuse stable semantics
│
┌────────────────────┼────────────────────┐
↓ ↓ ↓
Domain Ontology Domain Ontology Use-Case Ontology
│ │ │
└──────── validated reusable semantics ───┘
│
↓
Governance backlog
│
↓
Promote to shared model
  • The shared ontology defines the common language: entities, relationships, identifiers, measures and conventions that are broadly agreed. Treat it as a stable, versioned dependency, not a model every project edits continuously.
  • Domain and use-case ontologies contain only the concepts, relationships, mappings and measures their consumers need, and evolve at the speed those consumers require.
  • Governance makes proven semantics converge over time, without requiring enterprise-wide alignment before value can be delivered.

The important design decision is not the number of ontologies but the boundary of semantic responsibility. Use domains to group related ontologies so they can be permissioned, tagged and monitored together. The Ontology Readiness board groups its verdicts by domain.

Where a concept belongs​

Put it in the shared/core ontology when…Put it in a domain or use-case ontology when…
The entity has one organizational meaningThe definition is specific to a process or analysis
Multiple teams need the same definitionThe model is expected to change quickly
Relationships are broadly agreedThe semantics are not yet validated for wider reuse
Measures or classifications should be standardizedSecurity requirements differ significantly
A stable semantic contract is valuableOnly a limited audience needs it

Typical shared concepts include Customer, Product, Supplier, Employee, Order, Location and Calendar.

Isolation by default, reuse by choice​

Treat the shared ontology like a shared software library:

  • Reuse what is stable and common.
  • Extend locally where requirements differ.
  • Do not change a global definition to satisfy a single use case.
  • Adopt shared-model changes deliberately, rather than forcing every dependent ontology to change at once.

In Timbr, you bring shared definitions into a domain ontology, and later move validated definitions back into the shared ontology, with a selective export into an existing knowledge graph. The export shows which entities are new, changed, deleted or unchanged in the target, and you choose exactly which ones to apply. See Export to a Different Environment and the ontology export and import SQL statements.

Promotion over upfront alignment​

A new definition does not have to enter the shared ontology before it can deliver value. Let shared models grow from validated business usage:

Business requirement
↓
Domain / use-case ontology
↓
SME validation
↓
Production usage
↓
Reusable semantics identified
↓
Governance review
↓
Promote selected components to the shared ontology

The shared ontology should not try to represent everything the organization knows. Its value comes from holding the most reusable and trusted semantics.


Modeling practices​

Model business entities, not source tables​

The ontology represents the business, not the database schema. Prefer concepts such as customer, order, product, shipment and facility over names such as dim_customer_v2, fact_order_header or sap_mara.

Physical differences belong in mappings, which absorb column names, source-specific codes, data types, transformations, filters and source identifiers. Consumers then query stable business semantics regardless of where the data lives.

One concept, many mappings​

When several systems hold instances of the same business entity, model them as multiple mappings of one concept. Create separate concepts only when the entities differ in meaning, not because the data comes from different systems. Querying the concept then returns the combined data from every mapped source.

Inheritance for real specialization​

Inheritance expresses an is-a relationship: the child is a specialization of the parent and inherits its properties and semantics.

employee
├── sales_employee
└── field_technician
  • Use it only when the child genuinely is a kind of the parent. Querying the parent automatically includes its children.
  • Define business subsets such as Active Customer or Open Incident as sub-concepts with business rules so the logic is written once.

Relationships for business navigation​

Relationships describe meaningful connections between business entities, for example customer places order, order contains product, employee works at facility.

  • Name relationships so a business user understands them. The same names are used by SQL, BI tools and AI agents.
  • Define inverse relationships so users can navigate the model in both directions.

Governed, reusable measures​

Define common calculations once as measures in the ontology instead of recreating them in dashboards, notebooks and applications. A governed measure should have:

  • A clear business definition, stored as the measure description
  • An owner, recorded as a tag
  • A documented grain and context
  • Defined filters and, where relevant, time behavior
  • Tests for expected behavior (see Readiness and testing)
  • A clear distinction from similarly named measures

Avoid over-modeling​

Not every physical column needs to become a property. Prioritize properties and relationships that carry business meaning, support navigation, are needed by consumers, or improve query generation and AI interpretation. A smaller, well-described ontology is usually more effective than a large one that reproduces a source schema.

Use ontology views and cubes to give a specific audience a focused interface over the ontology without duplicating concepts.

Describe and tag everything consumers see​

Descriptions are what people and AI agents read when deciding which concept, property or measure to use. Add descriptions to concepts, properties, relationships, measures and views, and use tags for ownership, classification, certification level, units and PII. See concept tags, property tags and AI Best Practices.


Ownership​

Governance is distributed, not performed entirely by a central team.

RoleTypical responsibilities
Shared ontology ownersShared definitions, cross-domain consistency, naming standards, promotion of reusable semantics, cross-domain conflicts, breaking changes
Domain / use-case ontology ownersDelivery, model and mapping accuracy, security configuration, performance, documentation, tests, evaluating updates from the shared ontology
Subject-matter expertsBusiness meaning, terminology, measures, relationships, classification rules, business constraints
Platform / governance teamModeling standards, tooling, ownership conventions, security guardrails, change monitoring, the promotion workflow

The platform or governance team defines and enforces the framework; it should act as an enabler and arbiter, not a mandatory approval step for every local edit.

Every production ontology should record:

  • Business owner and technical owner
  • Domain and purpose
  • Main consumers
  • Security classification
  • Lifecycle status

Record these in the ontology/domain description and tags.


Change and version management​

Treat shared ontologies as versioned contracts​

Changes to a shared ontology affect every consumer, so they should be intentional, traceable and reviewed according to their impact.

  • Release a version before a significant change, with a label and a note on what it contains. Any release can be restored, as a whole or one object at a time.
  • Review what changed since the last release in Version Control, and revert single objects if needed.
  • When the same object is defined in several ontologies, check whether the copies still match from the Version Control tab.
  • Try larger changes on a branch before applying them to the main ontology.
  • Keep the full definition under source control by storing the output of EXPORT ONTOLOGY alongside your other code.
  • Promote between development, staging and production environments with export and import rather than editing production directly.

Compare before adopting​

Before applying an update, understand what changed: new or removed concepts, changed properties, relationships, mappings, measures and security. When exporting into an existing knowledge graph, Timbr shows a comparison of new, changed, deleted and unchanged entities and lets you Preview SQL before applying anything.

Review deletions

Deleted entities are removed from the target knowledge graph if selected. Confirm the impact on views, cubes and saved queries before applying them.

Additive versus breaking changes​

Usually additivePotentially breaking
New conceptRenaming a concept or property
New optional propertyChanging the meaning of an existing concept
New relationshipRemoving a property
New measureChanging identifiers
Changing relationship semantics
Changing a widely used measure definition

Breaking changes deserve more scrutiny, a notice to the owners of dependent ontologies, and a check with Data Lineage of what depends on the element.

Promotion backlog​

Keep a backlog of reusable semantics discovered in domain and use-case ontologies. Typical promotion criteria:

  • Used by several use cases, and stable over time
  • Validated by the relevant SMEs
  • Clearly owned
  • Compliant with modeling standards
  • Documented and covered by tests
  • Free of unnecessary coupling

Two review paths​

Keep local changes lightweight and focus central review on shared semantics, security and high-impact changes.

Domain / use-case changeShared ontology change
1. Developer or SME proposes the change1. Promotion candidate or direct request
2. Local review2. Owner identified
3. Readiness tests and validation3. Cross-domain impact and semantic review
4. Security check4. Security review
5. Deploy5. Comparison and compatibility review
6. Observe production usage6. Readiness tests
7. Approval and release
8. Notify affected ontology owners

Readiness and testing​

Governance should rely on automated validation, not only manual review.

  • Run VALIDATE ONTOLOGY to check the integrity of concepts, relationships, properties, mappings and views.
  • Use Ontology Readiness test suites to assert expected behavior and get a READY / NOT READY verdict per ontology. Suggest tests generates calibrated candidates from the ontology itself.
  • Schedule recurring suite runs with RUN TESTSUITE through Scheduled Jobs, and re-run after every significant change. A run is flagged STALE when the ontology has changed since it completed.
  • Keep profiling current so statistics reflect the data.
Test typeChecks
StructuralRequired concepts, properties, relationships and mappings exist and remain valid
MappingMappings still resolve against the source and return data
Data qualityIdentifiers are not null, business keys are unique, row counts meet a minimum, values are in range, data is fresh
Semantic regressionKey measures, relationships and concepts still return the expected results for known queries
Release gates

For shared and critical ontologies, a NOT READY verdict on high-severity tests should block promotion to production.


Security​

Treat security as part of ontology design, not an afterthought. The recommended access chain is:

Identity provider / SSO  →  Enterprise groups  →  Timbr roles  →  Ontology permissions  →  Row-level policies
  • Least privilege. Timbr separates ACCESS, QUERY and EDIT permissions. Users who only consume data should not receive EDIT.
  • Roles, not users. Grant permissions to roles that correspond to business, domain or platform responsibilities, and map them to groups from your SSO provider. Minimize direct user grants.
  • Row-level restrictions. Use security policies on concepts, properties, mappings and views, and grant them to roles.
  • Global guardrails. Even with decentralized ownership, require explicit protection for restricted data, defined ownership for every production ontology, and auditable privileged changes.
  • Regular review. Audit permission assignments, role membership, assigned policies, privileged access, orphaned permissions and overly broad access with the permission system tables: SYS_PERMISSIONS, SYS_PERMISSION_HISTORY, SYS_USERS_ROLES and SYS_ASSIGNED_POLICIES. See System Tables.

Scaling the estate​

As the number of ontologies grows, governance shifts from approving individual edits to making models discoverable, comparable, reusable and interoperable.

Organization-wide conventions​

Standardize naming for concepts, properties, relationships, identifiers and measures, and standardize descriptions, tags and ownership metadata. Shared conventions make independently built ontologies easy to understand and reconcile.

Purpose-driven ontologies​

Each ontology should have a clear purpose. Avoid nearly identical ontologies created independently by different teams, and avoid copying an entire shared ontology into every project. Reuse only what is needed.

Track semantic overlap​

Review the estate regularly, using the system tables to compare concepts across ontologies:

PatternAction
Same name, same meaningCandidate for shared reuse
Same name, different meaningClarify scope or rename
Different names, same meaningConsolidation candidate
Repeated measure logicPromotion candidate

Performance without changing semantics​

  • Keep semantics independent of storage. Consumers query business concepts without needing to know whether the data is in a warehouse, a lakehouse, an operational database or a cache.
  • Materialize selectively. Cache based on measured need: expensive, frequently reused joins, high-volume analytical paths, common aggregates, high-latency sources, and workloads that need predictable interactive response.
  • Do not duplicate the model for performance. Optimize mappings, storage and materialization while keeping the semantic contract stable.
  • Define operational ownership for availability, mapping failures, source schema changes, cache job failures, data freshness, query performance and security incidents. Monitor jobs and queries through the system tables and the Performance Dashboard.

Minimum production standards​

Every production ontology should meet this baseline:

AreaMinimum standard
OwnershipBusiness and technical owner identified
PurposeUse case or domain documented
NamingShared naming conventions followed
ConceptsBusiness-oriented rather than source-oriented
RelationshipsBusiness meaning documented
MeasuresDefinition and owner documented
MappingsValidated against source data
TestingCritical mappings and semantics covered by a readiness suite
SecurityLeast-privilege, role-based access and required policies applied
DocumentationCritical concepts and properties described
Change managementChanges traceable and reviewed according to impact
Shared-model alignmentReusable semantics periodically evaluated for promotion

Governance cadence​

Governance works best as a continuous lifecycle rather than a one-time design exercise.

WhenActivities
Per changeValidate the model, run readiness tests, review security, assess compatibility where needed
Per releaseCompare ontology differences, document significant semantic changes, validate critical measures and mappings, back up the ontology
PeriodicallyReview duplicated concepts and promotion candidates, review permissions and policies, retire unused or deprecated elements, confirm ownership, refine standards from lessons learned