Microsoft Fabric
Microsoft Fabric Governance with Microsoft Purview: A Practical Architecture Guide
How to govern a growing Microsoft Fabric platform: domains, workspaces, lineage, sensitivity labels, OneLake security, endorsement and where Microsoft Purview fits.
On this page
Most Fabric platforms do not start with a governance plan. They start with one workspace, a few notebooks, a Lakehouse and one Power BI semantic model that a single team understands completely. Governance at that size is a conversation across a desk.
Then the platform succeeds. A year later there are dozens of workspaces, several teams, hundreds of tables, multiple business domains, separate development, test and production environments, shared data products, consumers outside the original team and data that is genuinely sensitive. Ownership, which used to be obvious, has become unclear.
At that point every governance discussion comes back to the same question:
Who owns the data, who can access it, where did it come from, what is trusted, and how do we control it at scale?
This guide answers that question as an architecture problem. It explains which governance controls Fabric provides natively, what Microsoft Purview adds, and how domains, workspaces, lineage, sensitivity labels, OneLake security and endorsement fit together. It is not a feature tour: the goal is a platform you can still reason about when it is ten times bigger.
Governance is a set of layers, not a tool
“Governance” is often treated as one product decision: turn on Purview and the problem is solved. In practice it is a stack of responsibilities, each owned by different people and enforced by different controls.
- Platform governanceHow the platform is configured
- Tenant settings
- Capacities
- Workspace boundaries
- Organizational governanceWho is responsible
- Domains
- Ownership
- Stewardship
- Data governanceWhat the data is and where it came from
- Lineage
- Sensitivity labels
- Catalog and endorsement
- Access governanceWho can see or change what
- Workspace roles
- Item permissions
- OneLake security
- SQL and model security
- Operational governanceHow change and usage are controlled
- Deployment
- Monitoring
- Audit
- Lifecycle
The layers are useful because they separate questions that are easy to conflate. A domain does not grant access. A sensitivity label does not hide rows. A workspace role does not tell a consumer whether a table is trustworthy. When a governance problem appears, the first step is to identify which layer it belongs to.
Native Fabric governance vs Microsoft Purview
Before designing anything, be precise about where each capability lives, because licensing and ownership follow from it.
Microsoft now positions the OneLake catalog as the primary place to discover and govern Fabric data. Its Govern section brings together domains, endorsement, governance insights and recommended actions, alongside administrative entry points for tenant settings, workspaces and capacities. Lineage and impact analysis are also built into Fabric. These capabilities are included with Fabric.
Microsoft Purview adds protection, risk and compliance capabilities on top, and requires Purview licensing:
- Information Protection: sensitivity labels and the protection policies associated with them.
- Data Loss Prevention (DLP): policies that detect sensitive information in supported structured items, such as lakehouses, warehouses, databases and semantic models, and raise policy tips and alerts.
- Audit: Fabric user activities are recorded in the Purview audit log.
- Insider Risk Management: risk indicators for supported Fabric activities.
- Broader estate governance: Purview can bring Fabric into an organization-wide catalog. The current Purview live view for Fabric is documented as a preview, and item-level metadata requires scans, so check its status before you rely on it.
| Concern | Native Fabric | Microsoft Purview |
|---|---|---|
| Discovery and catalog of Fabric items | OneLake catalog | Organization-wide view through live view (preview) and scans |
| Business grouping and ownership | Domains, subdomains, domain admins | Not required |
| Lineage and impact analysis | Workspace lineage view, impact analysis | Not required for Fabric-internal lineage |
| Trust signals | Endorsement: Promoted, Certified, Master data | Not required |
| Classification | Applies, displays and propagates labels | Defines labels and label policies |
| Loss prevention and insider risk | Not available natively | DLP, Insider Risk Management |
| Audit | Activity events, OneLake diagnostics | Purview audit log |
The practical rule: Fabric governs how the platform is organized and used; Purview governs how sensitive information is protected and audited across the organization. Purview does not automatically govern every Fabric item in every way. Each integration has its own supported item types and limitations, and some are in preview. Treat each one as a separate decision.
Domains: the organizational layer
A domain in Fabric is a logical grouping of the data that belongs to one business area. A domain might be Sales, Finance or Operations, plus a Data Platform domain for the shared, cross-cutting assets the platform team owns.
- Fabric tenant
- Sales
- Sales Dev
- Sales Test
- Sales Prod
- Finance
- Finance Dev
- Finance Prod
- Operations
- Ops ingestion
- Ops serving
- Data Platform
- Shared dimensions
- Monitoring
How domains work in practice:
- Workspaces are assigned to domains. When a workspace joins a domain, every item in it is associated with that domain. Subdomains refine the grouping further.
- Domains have owners. A Fabric admin creates domains and names domain admins, ideally the business owners or designated experts for that area. Domain contributors, who must be workspace admins, can assign their own workspaces to the domain.
- Domains improve discovery. Consumers filter the OneLake catalog by domain to find the data that is relevant to them.
- Domains delegate governance. Some tenant settings can be delegated to the domain level. Certification is the clearest example: a domain can enable certification and name its own certifiers. Where the organization enables it, a domain can also set a default sensitivity label for items in its workspaces.
What domains do not do is equally important. Domain assignment does not change who can see or access an item. Access still comes from workspace roles and item permissions. A domain is an ownership and discoverability boundary, not a security boundary. The most common design mistake is to treat “Finance domain” as if it secures finance data. It does not.
Design domains with the business architects, not only the platform team. A good test: for each domain, can you name the one person who decides what “correct” means for its data? If not, the domain is a folder, not an ownership boundary. Microsoft Fabric Domains Explained covers roles, workspace assignment methods, delegated settings and a domain design checklist.
Workspaces: lifecycle, ownership and security boundaries
If domains are the organizational boundary, workspaces are the operational one. A workspace is where items live, where roles are assigned, where Git is connected and what deployments target. Its responsibilities are concrete:
- Lifecycle: items in a workspace are versioned and deployed together.
- Permissions: workspace roles (Admin, Member, Contributor, Viewer) are the broadest access control on everything inside.
- Environment separation: Dev, Test and Prod are separate workspaces, never folders in one workspace.
- Team ownership: a workspace has an accountable team, and its admins are known people, not “whoever created it”.
- Deployment: CI/CD promotes item definitions from one workspace to the next.
A typical pattern inside one domain:
- Sales domainOwned by the Sales data owner
- Sales DevEngineers build and test
- Sales TestValidated by CI/CD
- Sales ProdConsumers read from here
When to add more workspaces depends on which boundary is under pressure:
| Separate by | When | Example |
|---|---|---|
| Environment | Always, once anything is consumed by others | sales-dev, sales-test, sales-prod |
| Domain | Different owners, rules or regulations | Finance separate from Sales |
| Team | Different release cadences or access needs within a domain | Ingestion team vs reporting team |
| Workload | Different capacity profiles or consumers | Heavy Spark ingestion vs interactive serving |
Microsoft’s own guidance also recommends isolated development workspaces per developer and splitting capacities by environment for workload isolation and chargeback (when capacity isolation pays off). Start with the fewest workspaces that keep environments and owners separate, and split further only when a real boundary appears. The workspace tutorial covers the basics, and Designing a Scalable Microsoft Fabric Architecture explains how workspaces, capacities and layers fit together.
Lineage: knowing where data came from
Lineage answers “where did this number come from?” and “what breaks if I change this table?”. In a Fabric platform the chain usually looks like this:
- Source system
- IngestionPipeline or notebook
- LakehouseBronze and Silver
- TransformationNotebook, Spark SQL or MLV
- WarehouseGold serving tables
- Semantic model
- Report
Fabric’s lineage view shows the relationships between all items in a workspace and the upstream connections one level outside it. Impact analysis shows the downstream items, including those in other workspaces, that a change would affect. Viewers can open lineage but do not see data sources.
Lineage matters for five practical reasons:
- Impact analysis: before you rename a column in a Gold table, you know which semantic models and reports depend on it.
- Incident investigation: when a report is wrong or stale, you walk upstream instead of guessing.
- Ownership: every node in the chain belongs to a workspace, and every workspace has an owner to call.
- Compliance: you can show where sensitive data flows and which outputs inherit it.
- Trust: consumers trust a certified model more when they can see it is built on governed sources.
Two practical caveats. First, Fabric lineage is item-level, not a column-level trace of every transformation. Second, lineage is only as readable as your naming. Consistent item names (lh_sales_silver, wh_sales_gold, sm_sales) make the graph useful. Generic names (Lakehouse 3, New semantic model) make it noise. Pipelines that log what they processed, as described in Monitoring Fabric Pipelines and Notebooks, complement lineage with run-level evidence.
Sensitivity labels and classification
Sensitivity labels classify items by how sensitive their content is: for example Public, General, Confidential and Highly Confidential. The labels and their policies are defined in Microsoft Purview Information Protection, at the organization level, and require Purview licensing. Fabric applies, displays and propagates them.
Labels serve two purposes:
- Business classification: everyone can see that a table or report contains confidential data and handle it accordingly.
- Protection: labels associated with protection policies can control access in the tenant, and labels on Power BI content travel with data through supported export paths such as Excel, PDF and PowerPoint.
Propagation is where expectations need the most care. Current Microsoft documentation describes:
- Default labeling for Fabric items, with limitations for non-Power BI items. For example, the label applies on create only where there is a clear create dialog.
- Downstream inheritance, on by default, from Fabric item to Fabric item and from Fabric item to Power BI item, but not from a Power BI item back to a Fabric item.
- Inheritance upon creation for specific cases, such as a notebook or pipeline created from a labeled Lakehouse.
- Inheritance from data sources, currently supported for Power BI semantic models only.
- Mandatory labeling, fully supported for Power BI items only.
- Domain-level default labels, where the organization enables them.
The architectural conclusion: do not assume that labeling a source automatically labels everything built from it. Design for coverage with default labels per domain, programmatic labeling for bulk cases, and a periodic review of unlabeled items. The OneLake catalog’s governance insights can show label coverage. And remember that a label classifies data. It does not replace access control on the data itself.
Access governance: which control applies at which layer
Access is where vague governance causes real incidents. Fabric has several layers of access control, and each protects a different surface. OneLake security documentation describes two planes. The control plane covers what you can do to an item: workspace roles, sharing and item permissions. The data plane covers what data you can see: OneLake security roles, down to tables, rows and columns.
| Layer | Control | What it governs | Key caveat |
|---|---|---|---|
| Workspace | Admin, Member, Contributor, Viewer roles | Everything in the workspace | Admin, Member and Contributor can read all data in the workspace |
| Item | Sharing and item permissions (Read, ReadData, ReadAll, Build, Write) | One item and its endpoints | ReadData and ReadAll open different paths: SQL vs OneLake |
| OneLake data | OneLake security roles, including table, row-level and column-level security | Data read through OneLake by Viewers and Read-only users | Does not restrict Admin, Member or Contributor |
| SQL analytics endpoint and Warehouse | GRANT, row-level security, column-level security, dynamic data masking |
T-SQL access | Applies to the SQL path only |
| Semantic model | Model permissions, row-level and object-level security | DAX queries through the model | Not enforced for users with Write permission on the model |
Three rules keep this manageable:
- Keep builders and consumers in different roles. Workspace Admin, Member and Contributor bypass data-level rules, so consumers should be Viewers or have item-level access only, ideally in a separate production workspace.
- Put rules as close to the data as the consumers’ paths require. If people read the same tables through Spark, SQL and Power BI, a rule defined only in the semantic model protects only one of those paths. OneLake security is designed to be enforced across Fabric engines. Model-level security protects only the model.
- Use security groups, not individuals. Assign roles to Microsoft Entra groups so that joining or leaving a team is an identity change, not a Fabric change.
The semantic model guide goes deeper into model permissions, row-level security and how Direct Lake checks access.
A data product trust model
Consumers rarely ask “which domain is this in?” They ask “can I use this?”. A simple trust model makes the answer visible.
- RawIngested as-is, engineering only
- InternalCleaned, owning team only
- CuratedDocumented and promoted for reuse
- CertifiedReviewed and endorsed for the organization
Fabric gives you native signals to express the top of this model through endorsement:
- Promoted: the item owner says it is ready for sharing and reuse. Anyone with write permission on the item can promote it.
- Certified: an authorized reviewer confirms it meets the organization’s quality standards. Only users specified by a Fabric admin can certify, and certification can be delegated per domain.
- Master data: the item is an authoritative source for core data such as customers or products. It applies only to items that contain data.
| Trust level | Who decides | Fabric signal | Typical location |
|---|---|---|---|
| Raw | Engineering team | None | Bronze Lakehouse, Dev or Prod |
| Internal | Owning team | None, workspace access only | Silver Lakehouse |
| Curated | Data product owner | Promoted | Gold Warehouse or Lakehouse, semantic model |
| Certified | Domain certifiers | Certified, or Master data for reference data | Production semantic models and Gold tables |
The model connects technical governance with consumer trust. Certification should mean something concrete: an owner is named, tests pass in CI/CD, lineage is clean, a sensitivity label is set, and a freshness expectation is documented. Raw and Internal are not bad. They are simply not promises. The Medallion Architecture guide explains the Bronze, Silver and Gold layers this model sits on.
Governance across Dev, Test and Prod
Environment governance is where the platform and operational layers meet.
- Separate workspaces per environment, assigned to the same domain, with different role assignments. Engineers are Contributors in Dev, but they read Prod; they do not edit it.
- Controlled deployment: changes move from Dev to Test to Prod through Git and a deployment process, not by editing production items in the browser. See Git integration in Microsoft Fabric and Fabric CI/CD with fabric-cicd.
- Approvals: production deployments go through a pull request or release gate with a named approver.
- Parameter and configuration separation: connection strings, Lakehouse IDs and environment-specific values are parameterized, so the same definition deploys everywhere.
- Secrets and identity: secrets live in a vault or in connections, never in notebooks or pipeline JSON. Deployments run as a service principal or workspace identity with the minimum roles required.
- Least privilege: the deployment identity can deploy to Prod; people generally cannot.
A useful check is to ask how a column gets renamed in production. If the honest answer is “someone edits it in the Prod workspace”, the environment boundary exists only on paper.
The governance architecture
Putting the layers together gives a reference architecture. Governance flows downward through the platform, and a set of concerns cuts across every tier.
Governance
- Microsoft PurviewLabels, DLP, audit, risk
- OneLake catalogGovern, domains, endorsement
Domain
- Business domainOwner, certifiers, delegated settings
Workspaces
- Dev
- Test
- Prod
Data
- LakehouseOneLake security
- WarehouseSQL permissions
Semantic model
- Semantic modelMeasures, RLS, OLS, endorsement
Consumers
- Reports
- Excel
- Apps and APIs
Cross-cutting concerns
- Identity
- Access
- Lineage
- Sensitivity
- Monitoring
- Deployment
Read the diagram as a set of contracts. Purview defines what sensitive means. The domain names who decides. The workspace defines who builds and who consumes. The data layer enforces access where the data actually lives. The semantic model publishes a governed, endorsed business view. Consumers receive something they can trust.
A governance operating model
Architecture without ownership decays. A simple responsibility split keeps each decision with the people who can make it:
| Role | Owns | Examples |
|---|---|---|
| Platform team | Tenant settings, capacities, standards | Who can create workspaces, capacity per environment, naming conventions, CI/CD templates |
| Domain owner | Ownership, policies, data products | Which workspaces belong to the domain, certification rules, default label |
| Engineering team | Implementation, lineage, quality, deployment | Pipelines, tests, readable item names, deployment through Git |
| Security and governance | Classification, access policy, audit | Label taxonomy, DLP policies, access reviews, audit investigations |
| Consumers | Approved usage | Use certified items, respect labels, request access through the defined process |
One person can hold several roles, especially in smaller organizations. The point is not headcount. It is that every decision has an owner who knows they own it.
Governance anti-patterns
These patterns appear repeatedly in Fabric platforms that grew faster than their governance:
- One giant workspace. Every team, environment and item in one place. Permissions become all-or-nothing, lineage is unreadable, and deployments collide.
- Everyone is Admin. Workspace Admin, Member and Contributor can read all data and bypass model-level rules. Granting them broadly removes most of your access controls.
- No ownership. Workspaces created by people who have since moved on, with no domain and no accountable owner.
- No environment separation. Development happens in the production workspace, so every experiment is a production change.
- No lineage discipline. Generic item names and ad hoc connections make impact analysis impossible exactly when you need it.
- Naming only, no policy. A
_confidentialsuffix is not a sensitivity label, and aprodprefix is not access control. - Governance after scale problems. Retrofitting domains, labels and roles onto hundreds of items is far harder than adding them as each workspace is created.
- Security only in the UI layer. Row-level security in one semantic model while consumers can query the same tables through the SQL analytics endpoint or OneLake.
Conclusion
Fabric gives you most of the building blocks for governance natively: domains for ownership, workspaces for lifecycle and access boundaries, lineage for traceability, endorsement for trust, and OneLake, SQL and semantic-model security for data access. Microsoft Purview adds organization-wide protection, loss prevention, audit and risk management. None of these pieces works alone, and none of them helps if it is added after the platform is already sprawling.
Governance should not be a separate project added after the platform is built. It should be part of the architecture from the beginning: decided when the first domain is named, enforced when the first workspace is created, and visible every time a consumer opens a certified semantic model.
More guides on ownership, access, lineage, trust and production controls are collected in the Data Governance & Security hub.
References
- Microsoft Learn — Governance and compliance in Microsoft Fabric
- Microsoft Learn — Use Microsoft Purview with Microsoft Fabric
- Microsoft Learn — Domains
- Microsoft Learn — Lineage in Fabric
- Microsoft Learn — Information protection in Fabric
- Microsoft Learn — Endorsement overview
- Microsoft Learn — OneLake data security overview
Was this helpful?
What could be better?
Thanks — that helps me improve Javi Builds.
Continue learning
- Cheat sheetMicrosoft Fabric Workspace Settings Cheat SheetThe Microsoft Fabric workspace settings that change how a data engineering workspace behaves: Spark pools, environments and jobs, domain assignment, OneLake shortcut caching and diagnostics, and data workflow (Apache Airflow job) runtime pools, with what to verify for each.Open cheat sheet
- ArticleIncremental Loads in Microsoft Fabric: Watermarks, CDC and MERGE Without Reprocessing EverythingStop full reloads in Microsoft Fabric without losing correctness: bounded watermark windows, Change Tracking vs CDC, Delta MERGE, deletes, late data and safe reruns.Read article
What should I build next?
I'm building Javi Builds around practical problems data engineers actually face. Tell me what you'd like to see next.
Stay in the loop
Get the Javi Builds updates you actually care about.
Check your inbox
I sent you a confirmation link. Your subscription will be active after you confirm it.