All resources

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

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

  1. IdentityWho is calling
  2. Tenant authorizationWhich tenants are allowed
  3. Request / pipelineCarries the tenant
  4. Data operationEnforced for one tenant
  5. Audit recordTenant, identity, operation
The tenant is resolved once, from the authenticated identity, then carried unchanged to the data and the audit record. Any hop that loses or re-derives it is a review finding.
  • 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.

Tags

  • Security
  • Data Architecture
  • Multi-Tenancy
  • Microsoft Fabric
  • Data Governance