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.

By JaviPublished 13 min readIntermediate

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.

  1. Platform governanceHow the platform is configured
    • Tenant settings
    • Capacities
    • Workspace boundaries
  2. Organizational governanceWho is responsible
    • Domains
    • Ownership
    • Stewardship
  3. Data governanceWhat the data is and where it came from
    • Lineage
    • Sensitivity labels
    • Catalog and endorsement
  4. Access governanceWho can see or change what
    • Workspace roles
    • Item permissions
    • OneLake security
    • SQL and model security
  5. Operational governanceHow change and usage are controlled
    • Deployment
    • Monitoring
    • Audit
    • Lifecycle
Five layers of governance in a Fabric platform. Each layer answers a different question and is enforced by different controls; no single feature covers all five.

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.

  1. Fabric tenant
    • Sales
      • Sales Dev
      • Sales Test
      • Sales Prod
    • Finance
      • Finance Dev
      • Finance Prod
    • Operations
      • Ops ingestion
      • Ops serving
    • Data Platform
      • Shared dimensions
      • Monitoring
Domains group workspaces by business responsibility. Workspaces are assigned to domains; every item in a workspace inherits that domain assignment.

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:

  1. Sales domainOwned by the Sales data owner
    • Sales DevEngineers build and test
    • Sales TestValidated by CI/CD
    • Sales ProdConsumers read from here
One domain, one workspace per environment

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:

  1. Source system
  2. IngestionPipeline or notebook
  3. LakehouseBronze and Silver
  4. TransformationNotebook, Spark SQL or MLV
  5. WarehouseGold serving tables
  6. Semantic model
  7. Report
End-to-end lineage in a Fabric platform. Lineage connects every hop from source to report; impact analysis reads the same graph in the other direction.

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:

  1. Business classification: everyone can see that a table or report contains confidential data and handle it accordingly.
  2. 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:

  1. 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.
  2. 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.
  3. 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.

  1. RawIngested as-is, engineering only
  2. InternalCleaned, owning team only
  3. CuratedDocumented and promoted for reuse
  4. CertifiedReviewed and endorsed for the organization
A practical trust model for Fabric data products. Each step adds ownership, quality checks and a stronger promise to consumers.

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.

  1. Governance

    • Microsoft PurviewLabels, DLP, audit, risk
    • OneLake catalogGovern, domains, endorsement
  2. Domain

    • Business domainOwner, certifiers, delegated settings
  3. Workspaces

    • Dev
    • Test
    • Prod
  4. Data

    • LakehouseOneLake security
    • WarehouseSQL permissions
  5. Semantic model

    • Semantic modelMeasures, RLS, OLS, endorsement
  6. Consumers

    • Reports
    • Excel
    • Apps and APIs

Cross-cutting concerns

  • Identity
  • Access
  • Lineage
  • Sensitivity
  • Monitoring
  • Deployment
A Fabric governance architecture. Purview and the OneLake catalog govern from the top; domains and workspaces carry ownership; identity, access, lineage, sensitivity, monitoring and deployment apply to every tier.

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 _confidential suffix is not a sensitivity label, and a prod prefix 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

Tags

  • Microsoft Fabric
  • Data Governance
  • Security
  • Fabric Workspace
  • Data Architecture