Checklist Microsoft Fabric
Data Platform Security Architecture Review Checklist
The security architecture questions to verify before approving a production data platform, for single-organization and multi-tenant platforms alike.
- Type
- Checklist
- Level
- Advanced
- Updated
- Format
- Printable
In short
Review identity, workspace boundaries, every data access path, tenant isolation, secrets, networking, service identities, audit, blast radius and recovery before a production data platform is approved. A checked box means the decision was explicitly reviewed, not assumed.
Who it is for
- Solution and data platform architects approving a production design
- Security, platform and operations reviewers in a design or readiness review
- Teams launching or migrating a multi-tenant data platform
What it helps you do
- Verify that every path to the data has a known, tested control
- Confirm tenant isolation and tenant context hold end to end
- Record blast radius, accepted risks and the approval decision
On this page
Use this checklist to review whether identity, workspace boundaries, data access, tenant isolation, networking, secrets, operations and recovery are designed consistently before a production data platform is approved. It fits architecture, design, pre-production, security, migration and multi-tenant platform reviews.
A checked box means the decision has been explicitly reviewed, not merely assumed. An unchecked box is either a decision still to make or a risk to accept in writing. Use the flagship Microsoft Fabric Security Architecture for Production Data Platforms for the reasoning behind each review question.
Two words are easy to confuse here. A platform tenant is a customer or business entity your platform serves. An Entra tenant is a Microsoft Entra ID directory. One Entra tenant usually hosts many platform tenants; keep the two apart in every review note.
1. Identity
- Human identities identified: builders, operators, analysts and consumers listed by group.
- Workload identities identified: every service principal, workspace identity and managed identity listed with its purpose.
- Groups, not individuals: roles and permissions assigned to groups; individual assignments are exceptions with a reason.
- Service principals documented: purpose, scope, owner and where each one is used.
- Workspace identity usage documented: which workspaces use one, and which connections authenticate with it.
- Managed identity usage documented: where Azure resources authenticate to the platform or its sources.
- Owners assigned: every non-human identity has a named owner team.
- Credential lifecycle defined: expiry, rotation and removal, with dates and an owner.
- Privileged identities reviewed: tenant administrators, capacity administrators and workspace Admins.
- No shared credentials: no account or secret is used by several people or unrelated workloads.
Evidence to capture: identity diagram · role matrix (identity → group → role → scope) · owner per identity · lifecycle and rotation process.
2. Workspace and environment boundaries
- Dev, test and prod separated: separate workspaces, identities, connections and data.
- Workspace purpose documented: one purpose per workspace (engineering, serving, sandbox), written down.
- Role assignments reviewed: a recurring review with an owner.
- Admin, Member and Contributor minimized: builder roles carry full data access inside the workspace.
- Consumer access model defined: consumers hold Viewer or item permissions, never builder roles.
- Privileged role use justified: each Admin or Member assignment in production has a recorded reason.
- Boundaries documented: platform, domain and application boundaries mapped to workspaces.
- Environment-specific identities: production runs with production identities only.
- Production access restricted: no routine human editing in production; changes go through deployment.
Review question: can someone with a workspace role bypass the lower-level control you intended to enforce?
3. Data access paths
List every path to each sensitive dataset. A path nobody mapped is a path nobody controls.
| Access path | Typically controlled by | Authoritative control here | Bypass tested |
|---|---|---|---|
| Semantic model | Model RLS/OLS, model permissions | ||
| Warehouse | SQL permissions, RLS, CLS, masking | ||
| Lakehouse | Workspace roles, item permissions, OneLake security | ||
| SQL analytics endpoint | SQL permissions, or OneLake security in user identity mode | ||
| Notebook (Spark) | Workspace role, OneLake security | ||
| Pipeline | Executing identity’s permissions | ||
| OneLake APIs and tools | Workspace role, OneLake security | ||
| Shortcuts | Target permissions and shortcut identity | ||
| API or external application | Application authorization, its service identity | ||
| Direct SQL client access | SQL permissions, network path |
- Authoritative control known: for each path, the control that actually enforces access is named.
- No engine bypass: another engine can’t read the same data without the same rule.
- Bypass testing performed: with real identities, through every path a user actually has.
- Read and write reviewed separately: who can change or delete data is reviewed, not only who can read it.
4. Data-level security
- RLS requirements documented: which datasets need row filtering, and on what attribute.
- OLS requirements documented: which tables or columns are hidden, and from whom.
- SQL permissions reviewed:
GRANT,DENY, RLS, CLS and masking in Warehouses and SQL endpoints. - Semantic-model permissions reviewed: read and build permissions, RLS role membership.
- Item permissions reviewed: shared items and their reshare or build rights.
- OneLake security reviewed: roles, scopes and which engines honor them.
- Direct-data-access paths reviewed: Spark, OneLake APIs and shortcuts that skip SQL and model rules.
- Privileged-user behavior understood: Admins, Members and Contributors are not filtered by most data-level rules.
- Default access documented: what a new member of each role sees before any rule applies.
| Dataset | Authoritative security control for this dataset |
|---|---|
5. Multi-tenant architecture
Skip this section for a single-organization platform. Otherwise, record the isolation model per customer class.
Isolation model selected:
- Shared data store (tenant ID column in shared tables)
- Schema or table separated
- Workspace per tenant
- Dedicated workspace, data store and capacity
- Hybrid by customer class
Checks:
- Tenants distinguished: platform tenant (customer) and Entra tenant are named separately in the design.
- Isolation model documented: per customer class, with the reason and the rejected alternatives.
- Tenant ID propagated end to end: from ingestion through storage, queries, outputs and logs.
- Authorization validated server-side: the tenant scope comes from the authenticated identity and a trusted mapping.
- UI filtering not relied on: a filter in the interface is never the only tenant control.
- Cross-tenant query tests performed: automated tests prove one tenant can’t read another through each path.
- Shared-service identity scope reviewed: what every shared identity can reach across tenants.
- Tenant-specific secrets used where required: no customer source credential shared across customers.
- Staging preserves tenant identity: intermediate tables and files keep the tenant ID.
- Logs include tenant context: every run, request and error record carries the tenant.
- Tenant access lifecycle defined: onboarding, user changes and offboarding per tenant, including data removal.
- Workspace-per-tenant provisioning automated: if used, workspaces, roles and items are created by code, not by hand.
- Cross-tenant shortcuts and sharing reviewed: no shortcut or shared item exposes one tenant’s data in another’s space.
- Role-union behavior understood: a user in several roles gets the combined access of all of them.
- Platform limits reviewed: role counts, members per role, workspaces and capacity limits fit the expected tenant count.
- Blast radius assessed per tenant: see section 12.
- Cost attribution available if needed: consumption attributable per tenant or customer class.
The multi-tenant report engine shows how the same rules apply in a data-serving API.
6. Tenant context propagation
- IdentityWho is calling
- Tenant authorizationWhich tenants are allowed
- Request / pipelineCarries the tenant
- Data operationEnforced for one tenant
- Audit recordTenant, identity, operation
- Trusted origin: tenant context comes from authorization, not from the request.
- Client-supplied tenant IDs validated: a tenant ID in a URL, header or parameter is checked against the caller’s allowed scope.
- Survives async processing: queued and background work carries the tenant explicitly.
- Pipelines preserve it: the tenant parameter is validated against configuration at each step.
- Retry and replay preserve it: a rerun processes and writes the same tenant only.
- Tenant ID in logs: on every execution and request record.
- Tenant ID in error records: where appropriate, without exposing other tenants’ data.
- No accidental loss or rewrite: downstream jobs can’t drop or overwrite the tenant identity.
7. Secrets and credentials
- No embedded credentials: none in code, notebooks, pipeline definitions, parameters or Git.
- No production secrets outside production: dev and test use their own credentials.
- Key Vault or reference strategy documented: where secrets live and how items reference them.
- Rotation process exists: scheduled, and tested outside production first.
- Owner assigned: each secret has an owner team.
- Workload identities preferred: managed or workspace identities instead of static credentials where supported.
- Tenant-specific secrets separated: where customer sources require their own credentials.
- Secrets not exposed: notebook output, pipeline run details and logs don’t show secret values.
- Revocation procedure exists: who revokes a credential, how fast, and what breaks.
8. Network and connectivity
- Public or private decision documented: and matched by configuration.
- Private Link requirement assessed: tenant-level or workspace-level, and what it changes for users and tools.
- Gateway strategy documented: on-premises and virtual network data gateways, ownership and high availability.
- On-premises connectivity reviewed: which sources, through which path, with which credentials.
- Outbound connectivity reviewed: where workspace items can connect out, and what is blocked.
- Cross-tenant limitations reviewed: what private networking blocks between Entra tenants.
- Firewall and network restrictions documented: on the sources, not only on the platform.
- Network is not authorization: private connectivity limits reachability; it doesn’t decide who reads what.
- Preview dependencies documented: any network feature in Preview is named, with its support status and fallback.
For private paths to SQL endpoints, see How to Secure SQL Endpoints in Azure.
9. Service-to-service security
- Identity for every automation documented: no production process runs without a known identity.
- Pipeline identity understood: which identity each pipeline and its activities run as.
- Notebook execution identity understood: interactive, scheduled and pipeline-triggered runs.
- Scheduled execution identity understood: schedules don’t depend on a personal account.
- Deployment identity documented: the identity CI/CD uses, and what it can change.
- API and application identity documented: how external applications authenticate and what they reach.
- Least privilege applied: each identity holds only the roles its operations need.
- Cross-workspace access reviewed: every identity with roles in several workspaces is justified.
- No catch-all service identity: one identity for everything only with a written justification.
| Operation | Identity used | Scope | Owner |
|---|---|---|---|
| Scheduled ingestion | |||
| Transformation notebooks | |||
| Deployment (CI/CD) | |||
| API or application access | |||
| Monitoring and audit export |
For a deployment identity pattern, see Microsoft Fabric CI/CD with fabric-cicd.
10. Governance and sensitive data
Governance tells you what the data is and who owns it; security controls who can use it.
- Sensitive data classified: every production dataset has a class.
- PII identified: personal data located and labeled.
- Regulated data identified: data under legal, contractual or industry rules.
- Financial data identified: and its reporting and retention rules.
- Tenant and customer data classified: including what each customer’s contract requires.
- Retention defined: how long each class is kept, and how it is removed.
- Lineage available: where sensitive data flows downstream.
- Ownership assigned: a data owner per domain or dataset.
- Sensitivity labels used where applicable: and their effect on export and sharing understood.
- Access reviews scheduled: with an owner and a record of each review.
See Microsoft Fabric Governance with Microsoft Purview for domains, labels, lineage and endorsement.
11. Auditing and observability
- Authentication failures visible: failed sign-ins for people and service identities.
- Authorization failures visible: denied access attempts are recorded.
- Permission changes logged: role, item and data-level permission changes.
- Privileged-role changes logged: and alerted on.
- Workspace changes auditable: creation, deletion, capacity and settings changes.
- Service identities included: non-human activity appears in the same audit trail.
- Tenant context in logs: a security event can be tied to one platform tenant.
- Suspicious patterns detectable: unusual volume, time or cross-tenant access raises an alert.
- Audit retention defined: long enough for investigations and contractual obligations.
- Incident owner defined: a named owner receives and acts on security alerts.
Evidence sources: Entra sign-in and audit logs · Fabric audit log · OneLake diagnostics · SQL audit · your execution log.
12. Blast radius
For each question, write what could be reached, then decide whether that is acceptable.
- One user compromised: what can that account reach?
- One service principal compromised: which workspaces, sources and tenants?
- One workspace compromised: which data and connections does it hold?
- One tenant boundary fails: which other tenants’ data becomes visible?
- One secret leaks: what does that credential open, from where?
- One pipeline runs with excessive privilege: what can it read, write or delete?
- One capacity or workspace hosts several tenants: who is affected by overload or misconfiguration?
| Blast radius | Record |
|---|---|
| Maximum acceptable blast radius | |
| Actual blast radius | |
| Gap / remediation |
13. Recovery and incident response
- Fast revocation: a compromised identity can be disabled quickly, and its dependent runs are known.
- Secret rotation tested: the procedure has been run, not only written.
- Tenant isolation survives replay and recovery: reprocessing writes each tenant’s data only to its own targets.
- Reruns preserve tenant boundaries: a partial rerun can’t pick up another tenant’s input.
- Restored data doesn’t mix tenants: restores and replays are checked per tenant.
- Incident owner defined: for security incidents on the platform.
- Security evidence retained: logs survive long enough to investigate.
- Post-incident access review possible: who accessed what, when, through which identity.
- Recovery doesn’t bypass controls: emergency access is time-bound, logged and removed afterwards.
14. Architecture decision record
Record the outcome of the review the same way as any other platform decision. See Designing a Production Data Platform for where security sits among the platform’s other decisions.
| Question | Record |
|---|---|
| Decision: what security architecture was selected? | |
| Why: what requirements drove it? | |
| Alternatives rejected: and why? | |
| Risks accepted: what remains, and who accepted it? | |
| Validation: how was the design tested? | |
| Review date: when should it be rechecked? |
15. Final sign-off
- Architecture reviewed
- Security reviewed
- Data owner reviewed
- Operations reviewed
- Multi-tenant isolation reviewed, if applicable
- Open risks documented, with owners
- Production approval decision recorded, with the date and the decision maker
This sign-off records that the review took place and what was decided. It is not a security certification or a compliance attestation.
Go deeper: related articles
Microsoft FabricAdvanced
Microsoft Fabric Security Architecture for Production Data Platforms
An architect's guide to securing production Microsoft Fabric platforms: threat model, identities, workspace boundaries, data-level controls and their bypass paths, multi-tenant isolation patterns, tenant context, secrets, networking, service identities, auditing and blast radius, with a reusable review checklist.
Microsoft FabricAdvanced
Designing a Production Data Platform: From Requirements to Operations
The decisions a data solution architect makes before building a production data platform: requirements and NFRs, source assessment, batch vs streaming, storage and serving, idempotency, security, observability, capacity, cost, RPO/RTO, governance and operational ownership, with a reusable review checklist.
Microsoft FabricIntermediate
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.
Cloud & AutomationAdvanced
Building a Multi-Tenant Report Engine on Azure and Microsoft Fabric
Design a multi-tenant report engine on Azure and Microsoft Fabric with metadata-driven reports, constrained custom queries, caching, pagination, asynchronous exports and capacity protection.
Build it: related projects
Modern Report Engine
The design of a reference implementation for secure, tenant-aware analytical requests, cache decisions, Fabric queries, exports and operational monitoring.
Fabric Data Platform Template
A reusable end-to-end Microsoft Fabric reference implementation: ingestion, Bronze, Silver and Gold layers, serving, Git, CI/CD and observability, built with practical engineering patterns.
Related talks
Designing Microsoft Fabric for Scale
The architecture decisions that decide whether a Fabric platform stays manageable as data, teams and workloads grow: workload boundaries, Lakehouse vs Warehouse, Medallion layers, capacity, Git and observability.
Formats: Talk · Webinar · Workshop · Internal session
Medallion Architecture Without Over-Engineering
Bronze, Silver and Gold as responsibilities rather than mandatory boxes: when all three layers help, when fewer are better, and how Delta, incremental processing, file design and data quality fit in.
Formats: Talk · Webinar · Workshop · Internal session