Abstract
As organizations adopt Microsoft Fabric, controlling access to sensitive data becomes an important architectural consideration.
Traditionally, securing data in Fabric involved managing workspace roles, item-level permissions, SQL security, and semantic-model restrictions. However, these approaches did not always provide a consistent way to enforce granular data permissions across different consumption methods.
OneLake Security introduces a centralized, role-based approach to securing data stored in OneLake. It enables organizations to control access to tables, schemas, files, individual rows, and columns without necessarily separating data into multiple Lakehouses or duplicating datasets.
But how does this work in practice?
This article explores OneLake Security through hands-on testing, including:
- Data-level security versus item-level sharing
- Access restrictions for report viewers and report builders
- Workspace permissions and the DefaultReader role
- SQL Analytics Endpoint security modes
- Workspace Identity and Single Sign-On (SSO)
- Security enforcement through OneLake shortcuts
- Row-level and column-level security in Direct Lake semantic models
- Limitations involving relationships, dynamic security, and deployment
The objective is to identify not only what OneLake Security supports, but also the design considerations organizations should understand before adopting it for enterprise workloads.
1. Introduction: Why OneLake Security Matters
Microsoft Fabric brings data engineering, data warehousing, analytics, and business intelligence into a unified platform built around OneLake.
While this architecture simplifies data management, it also raises an important question:
How can organizations make the same data available to different users without exposing information they are not authorized to access?
Consider an organization with employee-related data containing general information, payroll information, and personally identifiable information (PII).
Different users may require access to different portions of that data:
- General analysts may need access to employee counts and organizational information.
- Finance teams may need access to payroll and financial information.
- HR teams may require access to selected personal employee information.
- Data engineers may need broader permissions to manage the underlying data and pipelines.
One approach is to create separate Lakehouses or datasets for each audience.
However, this introduces additional complexity, duplication, maintenance overhead, and potential inconsistencies.
OneLake Security provides an alternative by allowing organizations to apply granular permissions directly to the data.
Rather than creating multiple physical copies, users can access the same underlying data through different security roles.
This becomes particularly useful when multiple reports, semantic models, and analytical tools depend on the same data foundation.
2. Understanding the Two Layers of Security
One of the most important concepts when implementing OneLake Security is understanding the difference between item access and data access.
These represent two separate concerns.
2.1 Item-Level Security: What Items Can Users Access?
Item-level security determines which Fabric resources users can access and what actions they can perform.
Examples include:
- Opening a Power BI report
- Accessing a semantic model
- Viewing a Lakehouse
- Creating or editing Fabric items
- Sharing content with other users
Item permissions and workspace roles control these capabilities.
For example, a report viewer may receive Read permission on a report, while a report builder may receive Read and Build permissions on a semantic model.
However, access to a Fabric item does not necessarily mean unrestricted access to all its underlying data.
2.2 OneLake Security: What Data Can Users Access?
OneLake Security operates at the data layer.
Using role-based access control (RBAC), administrators can define which data users are authorized to access.
Permissions can be scoped to:
- An entire Lakehouse
- Selected schemas
- Individual tables
- Files and folders
- Specific rows using Row-Level Security (RLS)
- Specific columns using Column-Level Security (CLS)
For example, a role could provide access to the General schema while excluding the Protected schema.
Another role could allow access to a financial table while restricting particular rows or sensitive columns.
The key principle is that granting access to a Fabric item and granting access to the underlying data are distinct operations.
When a connection uses per-user identity and OneLake Security, both the appropriate item permissions and data permissions must be considered.
The distinction is particularly important because Fabric also supports fixed-identity connections, where the identity used to access the source may differ from the report consumer.
3. Testing OneLake Security in Practice
The following scenarios were tested using synthetic data divided into two schemas: General (non-sensitive data) and Protected (restricted data). Testing was performed using accounts with limited permissions.
| # | Scenario | Test Description | Observed Result |
|---|---|---|---|
| 1. | Lakehouse Sharing Without Data Access | Shared a Lakehouse with a user without assigning a OneLake Security role. | The user could open the Lakehouse, but no tables or schemas were visible. |
| 2. | Schema-Level Access | Created a OneLake role granting access to the General schema while restricting Protected. | The user could view and query General tables, while Protected data remained inaccessible. |
| 3. | Report Sharing with Mixed Data | Shared a Power BI report containing visuals from both General and Protected schemas with a user authorized for General only. | General visuals loaded successfully, while visuals relying on Protected data returned errors or failed to load. |
| 4. | Report Builder Access | Granted Read and Build permissions on an existing semantic model with restricted OneLake access. | The user could create reports using authorized data but could not modify the semantic model or access restricted data. |
| 5. | Semantic Model Builder Access | Shared the source Lakehouse with restricted OneLake permissions, allowing the user to create a semantic model in a separate workspace. | The user could build semantic models using authorized tables without requiring access to the source workspace. |
Key takeaway: These tests demonstrated that OneLake Security can enforce granular data restrictions independently of item sharing, allowing different users to consume and build reports using the same underlying Lakehouse without granting unrestricted data access.
4. Critical Security Considerations
The initial tests demonstrated that OneLake Security could successfully restrict access to selected data.
However, additional testing revealed several important considerations that can significantly affect the security design.
4.1 Workspace Permissions Can Provide Broader Access Than Expected
OneLake Security roles use a grant-based permission model.
This means that a restrictive role does not automatically remove access granted through another role or permission.
For example, assigning a user to a role that allows access to only one schema does not guarantee that the user cannot access other schemas. They may already have broader permissions elsewhere.
One particularly important mechanism is the default role known as DefaultReader.
For Lakehouses, this role can grant broad read access to users who have the appropriate ReadAll permission.
In addition, workspace Admins, Members, and Contributors generally receive elevated data access through their workspace permissions.
These permissions can make narrowly scoped OneLake roles ineffective at restricting those users.
Implementation consideration
Before assigning restricted OneLake Security roles, review the user’s existing workspace and item permissions, including membership in DefaultReader.
For users who only need to consume reports or approved datasets, prefer appropriately scoped item-level sharing over unnecessarily broad workspace permissions.
4.2 SQL Analytics Endpoint: The Importance of Data Access Mode
Another significant finding involved the SQL Analytics Endpoint. The SQL endpoint supports different data access modes, and the selected mode determines which security mechanism is applied.
Delegated Identity Mode
In delegated identity mode, the SQL endpoint uses its SQL security model rather than directly enforcing OneLake Security roles.
As a result, OneLake restrictions and SQL permissions may produce different access outcomes.
If SQL permissions are configured more broadly than intended, users may be able to query data that their OneLake roles would otherwise restrict.
User Identity Mode
User identity mode allows the SQL endpoint to evaluate OneLake Security permissions for the requesting user.
This provides an approach for aligning SQL query results with OneLake data restrictions.
Key finding
Configuring OneLake Security roles does not eliminate the need to validate the security configuration of every supported data access path.
When centralized OneLake enforcement is required, verify that the SQL Analytics Endpoint is configured to use User Identity (OneLake Security).
Otherwise, the SQL endpoint must be secured through an appropriate SQL permission model.
5. Workspace Identity, SSO, and Direct Lake Semantic Models
One of the additional scenarios investigated how Workspace Identity interacts with Direct Lake semantic models and OneLake Security.
Workspace Identity provides a managed Microsoft Entra identity associated with a Fabric workspace.
This can help organizations avoid relying on credentials owned by individual employees.
However, introducing a shared identity requires careful consideration of how user permissions are evaluated.
5.1 Testing Workspace Identity
A Direct Lake semantic model was configured using a Workspace Identity connection.
Initially, the connection encountered permission-related issues because the Workspace Identity did not have the required access to the source data.
After granting the identity the necessary OneLake permissions, the connection and refresh operations succeeded.
When SSO was enabled, the effective permissions of individual report consumers continued to be evaluated against OneLake Security.
Key finding
Workspace Identity does not automatically bypass OneLake Security.
The identity must have appropriate access for the operations it performs, while SSO determines whether the current user’s permissions are evaluated when queries are executed.
6. Advanced Testing: Row-Level and Column-Level Security
Beyond table- and schema-level permissions, additional tests explored how OneLake Security behaves when more granular restrictions are introduced.
6.1 Row-Level Security Across a Star Schema
One of the most important findings emerged when testing RLS on a semantic model built using a star schema.
The model contained a fact table connected to multiple dimension tables.
A OneLake RLS rule was applied to a dimension table to restrict its rows to a particular country.
Expected behaviour
When a user accessed the semantic model, the restricted dimension data would be visible.
We also wanted to determine whether the restriction would propagate through the semantic-model relationships and affect calculations based on the fact table.
Observed result
Visuals directly using the restricted dimension reflected the applied filter.
However, some fact-table measures and card visuals continued to display totals that included data beyond the restricted subset.
In other words, applying OneLake RLS to the dimension table did not automatically filter the related fact table in the same way that relationship-based semantic-model RLS might.
Why this matters
OneLake RLS is applied to the underlying table.
It should not be assumed that the restriction automatically propagates through semantic-model relationships to secure other tables.
This is particularly important for enterprise dimensional models.
For example, restricting a department dimension does not automatically guarantee that salary or headcount measures in a related fact table will be restricted to that department.
Implementation consideration
When using OneLake RLS with star schemas, validate both dimension-level visuals and fact-based measures.
If sensitive fact-table data must be restricted, apply an appropriate security policy to the fact table itself rather than relying solely on relationships.
6.2 Combining OneLake RLS with Semantic-Model RLS
The next test examined what happens when OneLake Security and semantic-model RLS define different access restrictions.
Two configurations were evaluated.
Scenario A: Semantic-model RLS is more permissive
OneLake Security allowed access to records associated with Canada.
The semantic-model RLS configuration allowed Canada and Brazil.
Observed result
The report displayed Canada only.
Brazil did not appear because the underlying OneLake Security policy had not authorized access to those records.
Scenario B: Semantic-model RLS is more restrictive
OneLake Security allowed Ontario and Quebec.
Semantic-model RLS allowed Ontario only.
Observed result
The report displayed Ontario only.
These results demonstrated that semantic-model permissions could not expand access beyond the restrictions enforced by OneLake Security in the tested configuration.
Additional tests using conflicting policies produced empty results or visual errors when the semantic model attempted to query inaccessible data.
Key finding
For the tested Direct Lake configuration, OneLake Security acted as the underlying data-access boundary, while semantic-model RLS could further restrict the accessible data.
Microsoft documentation also describes OneLake rules being evaluated before semantic-model security rules when both layers are used.
However, combining security mechanisms increases complexity.
Organizations should minimize overlapping security rules where possible and validate the effective permissions experienced by end users.
6.3 Column-Level Security Validation
Column-level security was tested using a table containing multiple fields.
Three columns were restricted through a OneLake Security role.
The resulting behaviour was evaluated through the semantic model and Power BI report.
Observed result
The restricted columns were inaccessible to the test user.
Report visuals that depended on those columns failed to load or display their expected results.
Other visuals that did not depend on restricted columns continued working.
Key finding
OneLake column-level security successfully protected sensitive fields through the tested reporting path.
This provides a useful mechanism for situations where a user should access a table but must not access particular attributes, such as personal identifiers or confidential financial information.
It is important to understand that CLS is not simply a cosmetic method for hiding columns from the interface.
It is a data-access restriction.
6.4 Current Limitations of Dynamic RLS
Another important consideration is the distinction between static and dynamic RLS.
OneLake Security supports assigning users and Microsoft Entra groups to different roles.
For example:
- A Canada role can access Canadian records.
- A United States role can access US records.
- A Finance role can access approved financial records.
However, OneLake RLS expressions use a restricted SQL syntax.
They do not currently provide the same flexibility as dynamic semantic-model RLS expressions that use functions such as USERPRINCIPALNAME() or lookup relationships against user-mapping tables.
OneLake RLS also does not support multitable queries within its rule definitions.
Implementation consideration
Organizations requiring highly dynamic, identity-driven access rules should carefully evaluate whether static OneLake roles meet their needs.
More complex requirements may require an alternative or complementary security architecture.
7. Can Users Bypass OneLake Security Through Shortcuts?
OneLake shortcuts allow users to reference data from other locations without creating a physical copy.
This raises an important question:
Can users create a shortcut to restricted data and access it through another Lakehouse?
To investigate this, shortcuts were created between Lakehouses.
The test users were granted access to selected source tables while other tables remained restricted.
Observed result
When creating shortcuts using the tested same-tenant access pattern, users could access only source data they were already authorized to read.
Restricted tables did not become accessible merely because a shortcut was created in another Lakehouse.
Users could also work with authorized shortcut data through their own Lakehouses and notebooks without gaining access to the restricted source tables.
Key finding
Shortcuts did not bypass the source OneLake Security restrictions in the tested configuration.
However, shortcut authentication modes matter.
Same-tenant shortcuts can use identity passthrough, while delegated shortcuts can operate using configured credentials.
These approaches have different security implications.
Therefore, the shortcut’s authentication model and permissions at both the source and destination should be reviewed during implementation.
8. Additional Implementation Challenges
Although the testing demonstrated several successful security scenarios, it also highlighted operational challenges that organizations should consider.
8.1 Lakehouse Compatibility and Query Behaviour
During early RLS testing, certain queries behaved differently across Fabric experiences.
In one case, an RLS-filtered table could be queried successfully through the SQL Analytics Endpoint, while accessing it through the Lakehouse experience produced an authorization error involving the Delta transaction log.
This demonstrated the importance of validating security through more than one query engine.
Schema configuration, supported runtimes, access modes, and engine compatibility can influence behaviour.
Microsoft also documents limitations involving RLS and CLS previews for non-schema Lakehouses and recommends using schema-enabled Lakehouses for those scenarios.
The important lesson is that a successful query through one Fabric engine does not automatically confirm identical behaviour through every other access path.
8.2 Security Role Propagation
Changes to security roles and group membership may not become visible immediately across every Fabric experience.
Security synchronization and caching can introduce delays.
During testing, it is therefore important to distinguish between:
- An incorrectly configured security role
- A missing permission
- An unsupported query path
- A synchronization or caching delay
These situations may produce similar symptoms but require different troubleshooting approaches.
9. Recommended Practices for Enterprise Implementations
Based on these tests and the documented platform behaviour, several practices are particularly important when designing secure Microsoft Fabric environments.
9.1 Apply the Principle of Least Privilege
Users should receive only the permissions required for their responsibilities.
Report viewers generally do not need Contributor permissions in the source workspace.
Similarly, report builders can often work with shared semantic models rather than direct access to all source data.
9.2 Separate Data Permissions from Item Permissions
Define which data a user is authorized to access before deciding how that data will be exposed.
Then grant the appropriate report, semantic-model, or Lakehouse permissions.
This reduces the risk of accidentally granting broader access through a convenient sharing mechanism.
9.3 Prefer Group-Based Role Management
Where practical, assign Microsoft Entra security groups to OneLake roles rather than managing large numbers of individual users.
This simplifies access administration and supports consistent onboarding and offboarding.
9.4 Validate Every Relevant Access Path
Do not limit security validation to a single report or Lakehouse view.
Test the permissions through the actual paths users will use, including:
- Lakehouse access
- SQL Analytics Endpoints
- Direct Lake semantic models
- Power BI reports
- OneLake shortcuts
- Notebooks and other approved data-processing tools
9.5 Test with Non-Privileged Accounts
Security tests performed using workspace administrators may not reflect the experience of ordinary users.
Use test identities with the same permissions as the intended consumers.
This is particularly important when verifying restricted data access.
9.6 Validate Security Against the Data Model
When using RLS with dimensional models, confirm that restrictions affect the required facts, measures, and report visuals.
Do not assume that a filter applied to a dimension table automatically protects all related fact tables.
9.7 Treat Security as Part of Deployment
Review OneLake roles, workspace permissions, item sharing, connection identities, and SQL endpoint modes during every deployment.
Retest effective access after significant model changes, role changes, or environment migrations.
10. Conclusion
OneLake Security represents an important advancement in Microsoft Fabric’s security architecture.
It allows organizations to move beyond relying primarily on workspace roles and item-level sharing, introducing more granular control over the data itself.
Our testing demonstrated that OneLake Security can effectively restrict access to schemas, tables, rows, and columns across several common Fabric consumption scenarios.
It also showed that implementing secure access requires more than simply creating a role.
Workspace permissions, SQL endpoint configurations, identity settings, semantic-model security, shortcuts, and the structure of the underlying data model all influence the final access experienced by users.
Some of the most valuable findings came from scenarios where behaviour differed from initial expectations, particularly around RLS propagation across star schemas and the interaction between OneLake Security and semantic-model security.
These observations reinforce an important principle:
Security should be validated against real usage patterns, not only against the configuration interface.
As OneLake Security and its deployment capabilities continue to mature, organizations have an opportunity to simplify their data architectures while strengthening centralized governance.
The key is to understand the boundaries of each security mechanism, implement least-privilege access, and test the complete data-consumption experience before production deployment.
Further reading
Microsoft Learn references for the security features and deployment considerations discussed in this article.
- OneLake Security: Access Control Model
- Creating and Managing OneLake Security Roles
- Direct Lake Security Integration
- Troubleshooting SQL Analytics Endpoint Security
- Row-Level Security Syntax
- OneLake Shortcut Security
- Lakehouse Git Integration and Deployment Pipelines