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:
| Need | Means |
|---|---|
| Consistency | Shared business concepts have stable, reusable definitions. |
| Speed | Individual teams and use cases deliver without a central bottleneck. |
| Autonomy | Domain teams and subject-matter experts (SMEs) evolve models close to the business. |
| Control | Security, 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.
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 meaning | The definition is specific to a process or analysis |
| Multiple teams need the same definition | The model is expected to change quickly |
| Relationships are broadly agreed | The semantics are not yet validated for wider reuse |
| Measures or classifications should be standardized | Security requirements differ significantly |
| A stable semantic contract is valuable | Only 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.
| Role | Typical responsibilities |
|---|---|
| Shared ontology owners | Shared definitions, cross-domain consistency, naming standards, promotion of reusable semantics, cross-domain conflicts, breaking changes |
| Domain / use-case ontology owners | Delivery, model and mapping accuracy, security configuration, performance, documentation, tests, evaluating updates from the shared ontology |
| Subject-matter experts | Business meaning, terminology, measures, relationships, classification rules, business constraints |
| Platform / governance team | Modeling 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 ONTOLOGYalongside 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.
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 additive | Potentially breaking |
|---|---|
| New concept | Renaming a concept or property |
| New optional property | Changing the meaning of an existing concept |
| New relationship | Removing a property |
| New measure | Changing 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 change | Shared ontology change |
|---|---|
| 1. Developer or SME proposes the change | 1. Promotion candidate or direct request |
| 2. Local review | 2. Owner identified |
| 3. Readiness tests and validation | 3. Cross-domain impact and semantic review |
| 4. Security check | 4. Security review |
| 5. Deploy | 5. Comparison and compatibility review |
| 6. Observe production usage | 6. 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 ONTOLOGYto 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 TESTSUITEthrough 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 type | Checks |
|---|---|
| Structural | Required concepts, properties, relationships and mappings exist and remain valid |
| Mapping | Mappings still resolve against the source and return data |
| Data quality | Identifiers are not null, business keys are unique, row counts meet a minimum, values are in range, data is fresh |
| Semantic regression | Key measures, relationships and concepts still return the expected results for known queries |
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,QUERYandEDITpermissions. Users who only consume data should not receiveEDIT. - 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_ROLESandSYS_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:
| Pattern | Action |
|---|---|
| Same name, same meaning | Candidate for shared reuse |
| Same name, different meaning | Clarify scope or rename |
| Different names, same meaning | Consolidation candidate |
| Repeated measure logic | Promotion 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:
| Area | Minimum standard |
|---|---|
| Ownership | Business and technical owner identified |
| Purpose | Use case or domain documented |
| Naming | Shared naming conventions followed |
| Concepts | Business-oriented rather than source-oriented |
| Relationships | Business meaning documented |
| Measures | Definition and owner documented |
| Mappings | Validated against source data |
| Testing | Critical mappings and semantics covered by a readiness suite |
| Security | Least-privilege, role-based access and required policies applied |
| Documentation | Critical concepts and properties described |
| Change management | Changes traceable and reviewed according to impact |
| Shared-model alignment | Reusable semantics periodically evaluated for promotion |
Governance cadence
Governance works best as a continuous lifecycle rather than a one-time design exercise.
| When | Activities |
|---|---|
| Per change | Validate the model, run readiness tests, review security, assess compatibility where needed |
| Per release | Compare ontology differences, document significant semantic changes, validate critical measures and mappings, back up the ontology |
| Periodically | Review duplicated concepts and promotion candidates, review permissions and policies, retire unused or deprecated elements, confirm ownership, refine standards from lessons learned |