An ontology provides a formal definition of business concepts, their properties, and the relationships between them. In a modern data platform, it helps connect technical data assets to business meaning, making information easier for analysts, applications, and AI systems to interpret.
In Microsoft Fabric, it is important to distinguish between building an ontology as a conceptual design and implementing it using Fabric’s data and semantic capabilities. A Power BI semantic model, for example, can define business entities, relationships, measures, and terminology, but it is not automatically a formal ontology.
Fabric provides the data engineering, analytics, and semantic modeling capabilities that can serve as the foundation for an ontology-driven solution.
Steps to Create an Ontology in Microsoft Fabric
Microsoft Fabric now includes an Ontology (preview) item that lets you define business entities, properties, relationships, and bindings to underlying data. You can create one from an existing semantic model or build it directly from data in OneLake.
(from Microsoft Learn)
1. Prepare your data
Organize relevant business data in a Fabric lakehouse or create a Power BI semantic model with appropriate tables, columns, relationships, and measures.
(from Microsoft Learn)
2. Create the ontology
To reuse an existing semantic model, open its overview page and select Generate Ontology. Alternatively, select + New item in your workspace and choose Ontology (preview) to build one from scratch.
(from Microsoft Learn)
3. Define entities and relationships
Create business entities such as Customer, Product, Store, and Sale. Define their properties, select appropriate entity keys, and establish relationships such as a Customer placing an Order.
(from Microsoft Learn)
4. Bind the ontology to your data
Map entity properties and relationships to the appropriate source tables and columns. This connects business definitions to actual enterprise data without requiring the ontology to duplicate that data.
(from Microsoft Learn)
5. Validate and use the ontology
Verify entity keys, property mappings, and relationships. You can then explore connected data through supported ontology experiences, including graph visualization and natural-language queries using Fabric data agent capabilities.
Example: A Retail Ontology
A retailer could define the following business relationships:
Customer
places
Sale / Order
contains
Product
belongs to
Product Category
With the relationships and data bindings configured, an AI-powered experience could use this shared business context to help answer questions such as, “Which customers purchased products in our premium category?”
Important Considerations
Preview status: As of October 2026, Fabric’s Ontology item is in preview, so capabilities and user interfaces may change.
Permissions and capacity: Check that your tenant has ontology functionality enabled, your workspace uses a supported Fabric capacity, and you have the required workspace and semantic model permissions.
Quality matters: Review generated entities and relationships rather than assuming the automatically created ontology is complete.
Start with business meaning: Agree on entity definitions, identifiers, and relationships before expanding the ontology across multiple data domains.
Conclusion
Creating an ontology in Microsoft Fabric helps organizations move beyond storing and reporting data toward representing the meaning of their business information. By building on existing semantic models or binding directly to OneLake data, organizations can create a reusable business context that supports connected analytics and AI applications.
This post is a part of the DP-800: Developing AI-Enabled Database Solutions Exam Prep Hub. This topic falls under these sections: Design and develop database solutions (35–40%) --> Design and implement SQL solutions by using AI-assisted tools --> Connect to MCP server endpoints, including Microsoft SQL Server and Fabric lakehouse
Note that there are 10 practice questions (with answers) at the end of each section to help you solidify your knowledge of the material. Also, there are 4 practice tests with 30 questions each available from the hub's main page below the exam topics section.
Introduction
As AI-powered development tools continue to evolve, developers increasingly need AI assistants that can interact with live enterprise systems rather than relying solely on the knowledge contained within large language models. The Model Context Protocol (MCP) provides a standardized way for AI assistants, such as GitHub Copilot and Microsoft Copilot, to securely connect to external tools, databases, services, and applications.
For DP-800 candidates, understanding how MCP enables AI-assisted database development is becoming increasingly important. Rather than simply generating SQL code, AI assistants can use MCP to retrieve database metadata, inspect schemas, execute approved queries, explore Fabric Lakehouse data, and assist with troubleshooting in real time.
This article explains how MCP works, how to connect to MCP server endpoints, common use cases involving Microsoft SQL Server and Microsoft Fabric Lakehouse, and best practices for secure implementation.
Learning Objectives
After studying this topic, you should be able to:
Understand the purpose of the Model Context Protocol (MCP)
Explain the relationship between AI clients and MCP servers
Describe how GitHub Copilot and Microsoft Copilot use MCP
Connect AI assistants to SQL Server MCP endpoints
Connect AI assistants to Microsoft Fabric Lakehouse MCP endpoints
Understand authentication and authorization requirements
Follow security best practices
Troubleshoot common MCP connection issues
What is the Model Context Protocol (MCP)?
The Model Context Protocol (MCP) is an open protocol that standardizes communication between AI applications and external systems.
Instead of building custom integrations for every database or service, AI clients communicate with MCP servers using a consistent protocol.
Think of MCP as a standardized “USB-C connector” for AI applications.
Without MCP:
AI Client
|
Custom SQL Connector
Custom Fabric Connector
Custom REST Connector
Custom File Connector
With MCP:
AI Client
|
MCP
|
-------------------------------------
SQL Server
Fabric Lakehouse
REST APIs
Files
GitHub
Azure Services
This standardized approach simplifies integration while improving maintainability and interoperability.
Why MCP Matters
Traditional AI coding assistants only generate code based on:
User prompts
Training data
Conversation history
Using MCP, AI assistants can also access:
Database schemas
Table definitions
Views
Stored procedures
Lakehouse metadata
Files
Documentation
Business knowledge
External APIs
This enables AI to generate more accurate, context-aware responses.
MCP Architecture
An MCP solution consists of three primary components.
MCP Client
The MCP client is the AI application.
Examples include:
GitHub Copilot
Microsoft Copilot
Visual Studio Code
Visual Studio
Other MCP-compatible AI assistants
The client sends requests to one or more MCP servers.
MCP Server
The MCP server exposes tools and resources that AI assistants can access.
Examples:
SQL Server
Fabric Lakehouse
Azure services
GitHub repositories
File systems
REST APIs
The server determines which operations are available.
Resource or Tool
Resources exposed by an MCP server may include:
Database tables
Views
Stored procedures
SQL execution tools
Schema information
Lakehouse metadata
Documentation
APIs
MCP Communication Flow
A typical workflow is:
Developer
↓
GitHub Copilot
↓
MCP Server
↓
SQL Server
↓
Results
↓
GitHub Copilot
↓
Developer
The AI assistant acts as the intermediary, translating user requests into approved tool invocations.
Connecting to an MCP Server
Connecting to an MCP server typically involves:
Configuring the AI client
Registering the MCP endpoint
Authenticating
Discovering available tools
Authorizing access
Using the available resources
Authentication
Authentication verifies the identity of the user or application.
Common authentication methods include:
Microsoft Entra ID
OAuth
Personal Access Tokens (PATs)
API Keys (less common)
Managed Identity (Azure-hosted scenarios)
Authentication occurs before any tool or data is accessed.
Authorization
Authorization determines what operations the AI may perform.
For example:
Allowed:
Read schema
Execute SELECT statements
View metadata
Denied:
DROP TABLE
DELETE production data
ALTER DATABASE
Least privilege remains an essential security principle.
Connecting to Microsoft SQL Server
An SQL Server MCP server exposes database capabilities to AI assistants.
Common resources include:
Tables
Views
Stored procedures
Functions
Database metadata
Execution plans
Query execution tools
Example workflow:
Developer asks:
Show me the Sales schema.
Copilot sends an MCP request.
SQL Server returns:
Tables
Columns
Relationships
Copilot explains the schema.
SQL Server MCP Use Cases
Examples include:
Schema Discovery
Instead of guessing table names:
Copilot retrieves:
Customers
Orders
Products
Sales
The generated SQL becomes much more accurate.
Generate SQL
Developer:
Show total revenue by country.
Copilot:
Reads schema
Finds relationships
Generates correct JOIN statements
Explain Stored Procedures
Developer:
Explain usp_ProcessOrders.
Copilot retrieves:
Procedure definition
Parameters
Business logic
Then provides a detailed explanation.
Query Optimization
Copilot can:
Inspect indexes
Analyze execution plans
Suggest rewrites
Recommend indexing improvements
Connecting to Microsoft Fabric Lakehouse
Fabric Lakehouse combines:
Data Lake
Data Warehouse
Spark
Delta tables
Using MCP, Copilot can interact with Lakehouse metadata.
Available resources may include:
Delta tables
Shortcuts
SQL endpoint metadata
Semantic information
OneLake structure
Fabric Lakehouse Use Cases
Examples include:
Discover Tables
Developer:
List all sales tables.
Copilot queries metadata.
Generate SQL Analytics Queries
Developer:
Calculate monthly sales growth.
Copilot examines available tables.
Generates optimized SQL.
Explain Lakehouse Structure
Developer:
Explain this Lakehouse.
Copilot can describe:
Schemas
Delta tables
Relationships
Storage organization
Data Exploration
Developers can ask:
Which tables contain customer data?
Which columns contain dates?
Which datasets contain revenue?
MCP Tool Discovery
One advantage of MCP is automatic discovery.
After connecting, Copilot can identify available tools such as:
Execute SQL
Read schema
Read documentation
Search metadata
Retrieve files
The user does not need to manually configure every capability.
Multiple MCP Servers
An AI assistant may connect to multiple MCP servers simultaneously.
Example:
GitHub Copilot
├── SQL Server MCP
├── Fabric Lakehouse MCP
├── GitHub MCP
├── Azure MCP
└── Documentation MCP
This allows a single conversation to span multiple enterprise systems.
Security Considerations
Organizations should never allow unrestricted AI access to production databases.
Best practices include:
Read-only access whenever possible
Least privilege permissions
Entra ID authentication
Audit logging
Approval workflows for sensitive actions
Data classification awareness
Secure network connectivity
Encryption in transit
Regular permission reviews
Network Considerations
Successful MCP connections require:
Network connectivity
Firewall configuration
DNS resolution
TLS encryption
Endpoint availability
Connection failures often result from blocked network paths or invalid authentication.
Common Connection Issues
Common problems include:
Authentication Failure
Possible causes:
Expired token
Invalid credentials
Missing permissions
Authorization Failure
The user authenticates successfully but lacks permission to use a tool.
Endpoint Unavailable
Possible causes:
Incorrect URL
Server offline
Network outage
Firewall Restrictions
Corporate firewalls may block communication.
Tool Discovery Failure
Possible causes:
Unsupported MCP version
Server configuration issues
Missing capabilities
Best Practices
Microsoft recommends:
Connect only trusted MCP servers.
Use Microsoft Entra ID when available.
Apply least privilege permissions.
Validate AI-generated SQL before execution.
Audit AI tool usage.
Separate development and production environments.
Monitor server logs.
Keep MCP server software updated.
Limit write operations unless required.
Review AI responses for correctness before acting on them.
SQL Server vs. Fabric Lakehouse MCP Connections
Feature
SQL Server MCP
Fabric Lakehouse MCP
Primary purpose
Relational databases
Lakehouse analytics
Objects
Tables, views, procedures
Delta tables, SQL endpoints
Typical queries
OLTP and reporting
Analytics and big data
Metadata
Database schemas
Lakehouse metadata
AI assistance
SQL generation, optimization
Analytics, exploration, SQL generation
DP-800 Exam Tips
For the exam, remember these key points:
MCP is a standardized protocol for connecting AI applications to external tools and data sources.
GitHub Copilot and Microsoft Copilot can use MCP servers to access live enterprise resources.
SQL Server MCP servers expose relational database metadata and tools.
AI assistants should operate with least privilege.
Developers remain responsible for validating all AI-generated code and database operations.
Organizations should use secure authentication, auditing, and network protections when deploying MCP-enabled AI solutions.
Summary
The Model Context Protocol (MCP) provides a standardized framework for connecting AI assistants with enterprise resources such as Microsoft SQL Server and Microsoft Fabric Lakehouse. By using MCP, GitHub Copilot and Microsoft Copilot can retrieve live metadata, understand database schemas, generate more accurate SQL, explain existing database objects, and assist with analytics. Proper authentication, authorization, auditing, and adherence to least privilege principles ensure that these powerful capabilities are implemented securely. As AI-assisted database development becomes more prevalent, understanding MCP connectivity and governance is an important skill for DP-800 candidates.
Practice Exam Questions
Question 1
A development team wants GitHub Copilot to retrieve SQL Server table definitions before generating SQL queries. Which technology enables this standardized communication?
A. SQL Server Integration Services (SSIS)
B. Model Context Protocol (MCP)
C. Open Database Connectivity (ODBC)
D. SQL Server Agent
Answer:B
Explanation: MCP provides a standardized protocol that enables AI clients to communicate with external systems such as SQL Server.
Question 2
What is the primary role of an MCP server?
A. Execute operating system updates
B. Store AI model weights
C. Expose tools and resources that AI clients can access
D. Replace Microsoft Entra ID authentication
Answer:C
Explanation: An MCP server exposes resources such as database schemas, SQL execution tools, documentation, and APIs to compatible AI clients.
Question 3
Which authentication mechanism is most commonly recommended for connecting GitHub Copilot to enterprise MCP servers?
A. Anonymous authentication
B. Basic authentication with shared passwords
C. FTP credentials
D. Microsoft Entra ID
Answer:D
Explanation: Microsoft Entra ID provides secure, enterprise-grade authentication with support for modern identity management.
Question 4
An AI assistant successfully authenticates to an SQL Server MCP endpoint but cannot execute a query because of insufficient permissions. Which security concept is responsible?
A. Encryption
B. Compression
C. Authorization
D. Serialization
Answer:C
Explanation: Authentication confirms identity, while authorization determines what actions an authenticated user is permitted to perform.
Question 5
Which capability is most likely exposed by a Microsoft SQL Server MCP server?
A. Reading database schema metadata
B. Azure virtual machine creation
C. Configuring Microsoft Teams
D. Managing Windows updates
Answer:A
Explanation: SQL Server MCP servers commonly expose database metadata, tables, views, stored procedures, and SQL execution tools.
Question 6
Why would an organization use least privilege when configuring MCP server access?
A. To minimize security risks by limiting allowed operations
B. To increase database storage capacity
C. To improve AI response speed
D. To reduce SQL Server licensing costs
Answer:A
Explanation: Least privilege ensures AI assistants receive only the permissions necessary to perform approved tasks.
Question 7
Which Fabric resource is most commonly explored through a Fabric Lakehouse MCP server?
A. Windows Registry
B. Delta tables and Lakehouse metadata
C. DNS records
D. Azure Firewall rules
Answer:B
Explanation: Fabric Lakehouse MCP servers expose Lakehouse metadata, Delta tables, SQL endpoints, and related analytics resources.
Question 8
A developer asks Copilot, “List every customer table in my Lakehouse.” What is the AI assistant most likely doing?
A. Guessing based on its training data
B. Downloading the entire database
C. Using an MCP server to retrieve live metadata
D. Reading Windows Event Logs
Answer:C
Explanation: MCP allows AI assistants to query live metadata rather than relying solely on pretrained knowledge.
Question 9
What is one major advantage of connecting GitHub Copilot to multiple MCP servers?
A. It permanently stores database credentials.
B. It allows a single AI conversation to access multiple enterprise systems and tools.
C. It eliminates the need for authentication.
D. It replaces source control systems.
Answer:B
Explanation: Multiple MCP servers enable AI assistants to work across databases, repositories, documentation, APIs, and other enterprise resources within one workflow.
Question 10
Which statement best reflects Microsoft’s guidance regarding AI-assisted database operations through MCP?
A. AI-generated SQL should be executed automatically without review.
B. Production databases should always grant AI assistants full administrative permissions.
C. MCP eliminates the need for database security controls.
D. Developers should review AI-generated code and queries before executing them.
Answer:D
Explanation: Although MCP provides rich contextual information, developers remain responsible for validating AI-generated code, ensuring correctness, security, and compliance before deployment or execution.
Part 3 – End-to-End Development Scenarios and Practice Exam Questions
This post is a part of the DP-800: Developing AI-Enabled Database Solutions Exam Prep Hub. This topic falls under these sections: Design and develop database solutions (35–40%) --> Design and implement SQL solutions by using AI-assisted tools --> Configure model and Model Context Protocol (MCP) tool options in a GitHub Copilot or Copilot in Fabric chat session
Note that there are 10 practice questions (with answers) at the end of each section to help you solidify your knowledge of the material. Also, there are 4 practice tests with 30 questions each available from the hub's main page below the exam topics section.
Introduction
Candidates should understand how AI models and MCP-enabled tools work together throughout the SQL development lifecycle—from planning and coding to testing, deployment, and optimization.
End-to-End SQL Development Workflow
The following illustrates a typical workflow for AI-assisted SQL development.
Requirements
│
▼
Developer Prompt
│
▼
GitHub Copilot /
Copilot in Fabric
│
▼
Selected AI Model
│
▼
(Optional)
Invoke MCP Tools
│
▼
Retrieve Context
• Database schema
• Existing procedures
• Documentation
• APIs
• GitHub repository
│
▼
Generate SQL
│
▼
Developer Review
│
▼
Testing
│
▼
Deployment
The AI assists throughout the workflow, but the developer remains responsible for reviewing, validating, and approving the generated solution.
Scenario 1 – Designing a New Database Table
A developer receives the following requirement:
Create a Customer table with auditing columns, primary key, email uniqueness, and indexes.
Prompt
Design a Customer table for Azure SQL Database. Include an identity primary key, audit columns, email uniqueness, and indexes for common lookup operations.
AI Response
The AI generates:
CREATE TABLE statement
PRIMARY KEY constraint
UNIQUE constraint
DEFAULT values
indexes
documentation
The developer reviews:
naming conventions
data types
indexing strategy
normalization
storage requirements
Scenario 2 – Creating Stored Procedures
The database already contains 150 tables.
Rather than manually examining the schema, GitHub Copilot uses an approved MCP server.
Developer prompt:
Create a stored procedure that returns all active customers with orders placed within the last 90 days.
Possible MCP interactions:
Read Customers table
Read Orders table
Discover foreign keys
Retrieve indexes
The AI produces SQL using the actual schema instead of making assumptions.
Scenario 3 – Query Optimization
A report currently takes 22 seconds.
Developer prompt:
Optimize this query for Azure SQL Database.
The reasoning model determines additional information is needed.
Using MCP:
retrieves execution plan
retrieves index information
retrieves statistics
retrieves row counts
The response includes:
rewritten SQL
missing indexes
parameter sniffing observations
SARGability improvements
estimated performance gains
Scenario 4 – Fabric Warehouse Development
A Fabric Warehouse contains several sales tables.
Developer asks:
Explain the warehouse schema and suggest a star schema optimization.
Copilot may retrieve:
warehouse metadata
table relationships
documentation
semantic model information
The AI can recommend:
dimension tables
fact tables
surrogate keys
partitioning
indexing
warehouse best practices
Scenario 5 – Documentation Generation
Developer prompt:
Document this database.
The AI generates:
table descriptions
column summaries
relationship explanations
stored procedure documentation
index summaries
security notes
This significantly reduces documentation effort.
Scenario 6 – Legacy SQL Refactoring
A SQL Server database contains code written fifteen years ago.
Developer prompt:
Modernize this procedure using current T-SQL best practices.
The AI may recommend:
TRY…CATCH
THROW
CTEs
window functions
JSON functions
simplified joins
improved naming
reduced duplication
Scenario 7 – Code Review
Developer prompt:
Review this stored procedure.
The AI evaluates:
security
SQL injection risks
indexing
readability
performance
maintainability
Rather than replacing human review, AI serves as an intelligent reviewer.
Scenario 8 – Database Migration
An organization is migrating SQL Server databases to Azure SQL Database.
Developer prompt:
Identify compatibility issues.
The AI reviews:
deprecated features
unsupported syntax
compatibility level
indexing recommendations
Azure SQL best practices
Scenario 9 – Troubleshooting Errors
A deployment fails.
Developer prompt:
Explain this SQL error.
The AI:
interprets error messages
explains root causes
recommends fixes
suggests troubleshooting steps
Scenario 10 – Learning Existing Code
A new developer joins the team.
Developer prompt:
Explain this stored procedure.
The AI produces:
high-level summary
business logic
table relationships
parameter explanations
execution flow
This accelerates onboarding.
Choosing the Appropriate Model
Development Task
Preferred Model
Generate CRUD statements
Fast model
Explain SQL syntax
Balanced model
Create stored procedures
Balanced model
Optimize execution plans
Reasoning model
Review security
Reasoning model
Database architecture
Reasoning model
Documentation
Fast/Balanced model
Refactoring
Balanced model
Code review
Reasoning model
Troubleshooting
Reasoning model
Choosing MCP Tools
Not every prompt requires MCP.
Use MCP when the AI needs:
live database metadata
repository contents
API specifications
execution plans
documentation
schema information
Simple questions such as
What is a clustered index?
generally do not require MCP.
Questions like
Show indexes on my Sales table.
typically do.
Common Development Mistakes
Trusting AI Without Validation
Always review generated SQL.
Using Production Data
Avoid exposing confidential production data unnecessarily.
Ignoring Security
Never assume generated permissions are correct.
Using the Wrong Model
Simple code generation does not always require a reasoning model.
Excessive Permissions
Only enable MCP servers with appropriate permissions.
Skipping Testing
Every generated SQL statement should be:
reviewed
tested
validated
Best Practices
Write detailed prompts.
Specify Azure SQL, SQL Server, or Fabric Warehouse when applicable.
Include schema information.
Use reasoning models for optimization tasks.
Use MCP only when external context is beneficial.
Enable only trusted MCP servers.
Follow least privilege.
Review generated SQL before execution.
Validate performance with execution plans.
Keep human oversight throughout the development lifecycle.
DP-800 Exam Tips
Candidates should remember:
AI models generate responses.
MCP connects AI to external systems.
Tools perform actions.
Resources provide information.
Prompts standardize interactions.
Authentication determines identity.
Authorization determines permissions.
AI operates within the user’s security context.
Developers remain responsible for validating all AI-generated SQL.
Practice Exam Questions
Question 1
A developer wants GitHub Copilot to recommend missing indexes based on the actual structure of an Azure SQL Database instead of making assumptions.
What should the developer configure?
A. A larger context window only
B. An MCP server that can expose database metadata and indexing tools
C. A faster AI model
D. A local SQL script containing only CREATE TABLE statements
Answer:B
Explanation:
An MCP server enables GitHub Copilot to access live database metadata, including tables, indexes, and statistics. This allows recommendations based on the actual database rather than inferred information. Increasing the context window or switching to a faster model alone does not provide access to external database metadata.
Question 2
A developer needs AI assistance to analyze an execution plan for a query that runs for several minutes.
Which model type is generally the best choice?
A. Fast code-completion model
B. Lightweight autocomplete model
C. Reasoning-focused model
D. Documentation generation model
Answer:C
Explanation:
Execution plan analysis requires complex reasoning and performance optimization capabilities. Reasoning-focused models are designed to analyze execution strategies, identify bottlenecks, and recommend indexing or query improvements.
Question 3
Which MCP component performs operations such as retrieving index information or executing an approved query?
A. Resource
B. Prompt
C. Client
D. Tool
Answer:D
Explanation:
Tools perform actions. Resources provide information, prompts are reusable instructions, and clients host the AI conversation. Retrieving index information or executing approved operations is performed through tools.
Question 4
A developer asks Copilot:
Explain what this stored procedure does.
No external information is required.
What is the most likely outcome?
A. Copilot automatically invokes every available MCP server.
B. Copilot requires administrator approval.
C. Copilot cannot answer without MCP.
D. Copilot answers using the supplied SQL and its language model.
Answer:D
Explanation:
If the prompt includes all necessary information, the AI can respond using its language model without accessing external tools. MCP is used only when additional external context is needed.
Question 5
Why should organizations implement the principle of least privilege for MCP servers?
A. To increase response speed
B. To reduce the number of AI prompts
C. To limit access to only the resources required
D. To improve SQL syntax generation
Answer:C
Explanation:
Least privilege reduces security risks by ensuring that AI assistants and users have access only to the resources necessary to perform their tasks.
Question 6
Which statement best describes the relationship between an AI model and MCP?
A. MCP replaces the language model.
B. MCP generates SQL while the model manages security.
C. The language model generates responses, while MCP enables access to external tools and resources.
D. MCP is another name for GitHub Copilot Chat.
Answer:C
Explanation:
The language model performs reasoning and response generation. MCP provides standardized access to external systems, tools, and resources that supply additional context.
Question 7
A developer wants Copilot to use repository documentation, API specifications, and database schemas when generating SQL.
What feature provides this capability?
A. Larger prompt length
B. Database compatibility level
C. MCP-enabled resources
D. SQL IntelliSense
Answer:C
Explanation:
MCP resources allow AI assistants to access external information such as documentation, schemas, and specifications, improving the relevance and accuracy of generated responses.
Question 8
After AI generates a stored procedure, what should happen next?
A. Deploy directly to production.
B. Trust the AI because it selected a reasoning model.
C. Execute immediately without testing.
D. Review, validate, test, and approve the code before deployment.
Answer:D
Explanation:
AI-generated code should always undergo code review, testing, validation, and approval before being deployed to production.
Question 9
Which scenario is most likely to benefit from an MCP server?
A. Explaining the syntax of a SELECT statement
B. Defining a PRIMARY KEY
C. Retrieving the latest schema and execution statistics from a production database
D. Explaining SQL keywords
Answer:C
Explanation:
Accessing current schemas and execution statistics requires live information from an external system, making MCP the appropriate solution.
Question 10
Why might a developer choose a balanced AI model instead of a fast model?
A. Balanced models are designed to provide stronger reasoning while maintaining good response speed.
B. Balanced models eliminate the need for testing.
C. Balanced models automatically execute SQL.
D. Balanced models replace MCP servers.
Answer:A
Explanation:
Balanced models provide a compromise between speed and reasoning quality, making them well suited for tasks such as stored procedure development, code explanation, and general SQL assistance. They do not replace testing, execute SQL automatically, or substitute for MCP functionality.
Final DP-800 Summary
For this objective, remember these core concepts:
AI models determine how responses are generated (speed, reasoning, and coding quality).
MCP determines what additional information or actions the AI can access by connecting to external tools and resources.
Tools execute approved operations, while resources provide contextual information.
Authentication identifies the user, and authorization limits what the AI can access on that user’s behalf.
Developers remain responsible for validating, testing, securing, and approving all AI-generated SQL before deployment.
These concepts are foundational to the DP-800 exam and reflect Microsoft’s direction toward secure, AI-assisted database development.
Note that there are 10 practice questions (with answers) at the end of each section to help you solidify your knowledge of the material. Also, there are 2 practice tests with 60 questions each available from the hub's main page below the exam topics section.
Introduction
Grouping and aggregating data are among the most common and important data transformation operations performed by data engineers. Organizations rarely analyze raw transactional data directly. Instead, they summarize, categorize, and aggregate data to create meaningful business metrics such as total sales, average order value, monthly revenue, customer counts, inventory levels, and operational KPIs.
In Microsoft Fabric, grouping and aggregation can be performed using several technologies, including:
SQL in Fabric Data Warehouses and Lakehouses
PySpark notebooks
Dataflows Gen2
KQL (Kusto Query Language)
Data pipelines as part of larger ETL/ELT processes
For the DP-700 exam, you should understand:
Why grouping and aggregation are important
When to aggregate data
How to implement aggregations using SQL, PySpark, KQL, and Dataflows Gen2
Common aggregation functions
Performance considerations
Aggregations in dimensional modeling and analytics solutions
Why Group and Aggregate Data?
Raw data often contains millions or billions of records.
For example:
OrderID
CustomerID
OrderDate
Amount
1001
C001
2026-01-01
250
1002
C001
2026-01-02
150
1003
C002
2026-01-02
300
Business users usually want summarized information such as:
CustomerID
TotalSales
C001
400
C002
300
This transformation is accomplished through grouping and aggregation.
Benefits include:
Faster analytics
Reduced storage requirements
Easier reporting
Improved dashboard performance
Simplified business intelligence models
Understanding Grouping
Grouping combines records that share common values.
Examples:
Group by:
Customer
Product
Region
Department
Date
Month
Year
Example:
Region
Sales
East
100
East
200
West
300
Grouped by Region:
Region
TotalSales
East
300
West
300
The GROUP BY operation creates logical categories before aggregation calculations occur.
Common Aggregation Functions
Data engineers should be familiar with the most common aggregation functions.
SUM()
Calculates totals.
Example:
SELECT Region,
SUM(SalesAmount) AS TotalSales
FROM Sales
GROUP BY Region;
Result:
Region
TotalSales
East
500000
West
750000
COUNT()
Counts rows.
SELECT Region,
COUNT(*) AS OrderCount
FROM Sales
GROUP BY Region;
Used for:
Number of customers
Number of transactions
Number of products
AVG()
Calculates averages.
SELECT ProductCategory,
AVG(SalesAmount) AS AverageSale
FROM Sales
GROUP BY ProductCategory;
Used for:
Average order value
Average response time
Average inventory level
MIN()
Returns the smallest value.
SELECT MIN(OrderDate)
FROM Orders;
Used for:
Earliest order
Lowest temperature
Minimum cost
MAX()
Returns the largest value.
SELECT MAX(OrderDate)
FROM Orders;
Used for:
Latest transaction
Highest sales amount
Maximum inventory quantity
Grouping and Aggregation Using SQL
SQL is the most common approach for aggregation in Fabric.
Example:
SELECT
ProductCategory,
SUM(SalesAmount) AS TotalSales,
COUNT(*) AS OrderCount,
AVG(SalesAmount) AS AverageSale
FROM Sales
GROUP BY ProductCategory;
This query:
Groups records by category
Calculates total sales
Counts orders
Calculates average sales
Multi-Column Grouping
You can group by multiple columns.
Example:
SELECT
Year,
Region,
SUM(SalesAmount) AS TotalSales
FROM Sales
GROUP BY Year, Region;
Result:
Year
Region
TotalSales
2025
East
500000
2025
West
700000
2026
East
550000
This provides more granular analysis.
Filtering Aggregated Results with HAVING
WHERE filters rows before aggregation.
HAVING filters after aggregation.
Example:
SELECT Region,
SUM(SalesAmount) AS TotalSales
FROM Sales
GROUP BY Region
HAVING SUM(SalesAmount) > 1000000;
Only regions exceeding $1 million in sales are returned.
Aggregation Using PySpark
PySpark is commonly used for large-scale aggregation operations in Lakehouses.
Example:
from pyspark.sql.functions import sum
sales_df.groupBy("Region") \
.agg(sum("SalesAmount").alias("TotalSales")) \
.show()
Result:
Region
TotalSales
East
500000
West
750000
Multiple Aggregations in PySpark
from pyspark.sql.functions import sum, avg, count
sales_df.groupBy("Region").agg(
sum("SalesAmount").alias("TotalSales"),
avg("SalesAmount").alias("AvgSales"),
count("*").alias("OrderCount")
)
This performs several calculations in a single operation.
Aggregation Using KQL
KQL is commonly used in Real-Time Intelligence workloads.
Example:
Sales
| summarize TotalSales=sum(SalesAmount)
by Region
Result:
Region
TotalSales
East
500000
West
750000
Multiple Aggregations in KQL
Sales
| summarize
TotalSales=sum(SalesAmount),
AvgSales=avg(SalesAmount),
OrderCount=count()
by Region
This pattern is common in real-time analytics.
Aggregation in Dataflows Gen2
Dataflows Gen2 provides a low-code interface.
Using the Group By transformation, users can:
Sum values
Count rows
Calculate averages
Find minimum values
Find maximum values
Typical steps:
Connect to source
Select Group By
Choose grouping columns
Define aggregation functions
Load results
This approach is useful for citizen developers and low-code ETL scenarios.
Aggregation in Dimensional Models
Aggregations are commonly used before loading data into fact and dimension tables.
Example:
Raw transactions:
OrderID
Customer
Amount
1
A
100
2
A
200
3
B
300
Aggregated customer sales:
Customer
TotalSales
A
300
B
300
This summary table can support reporting and dashboards.
Fact Table Aggregations
Fact tables often store:
Transaction-level facts
Daily summaries
Monthly summaries
Examples:
Transaction Fact
OrderID
Amount
1001
50
Daily Aggregate Fact
Date
TotalSales
2026-01-01
50000
Aggregated fact tables improve query performance.
Window Aggregations vs Group Aggregations
Data engineers should understand the difference.
Group Aggregation
Returns one row per group.
SELECT Region,
SUM(SalesAmount)
FROM Sales
GROUP BY Region;
Window Aggregation
Preserves detail rows.
SELECT
OrderID,
Region,
SalesAmount,
SUM(SalesAmount)
OVER(PARTITION BY Region)
AS RegionTotal
FROM Sales;
Useful for:
Running totals
Rankings
Percentages
Advanced analytics
Performance Considerations
Grouping and aggregation can be expensive.
Best practices include:
Filter Early
Reduce data before aggregation.
WHERE OrderDate >= '2026-01-01'
Aggregate Close to the Source
Avoid moving unnecessary detailed records.
Use Partitioning
Partitioning helps Spark process data efficiently.
Examples:
Date
Region
Customer segment
Use Delta Tables
Delta tables improve performance through:
Data skipping
File optimization
Efficient query execution
Avoid Excessive Cardinality
Grouping on highly unique columns can reduce efficiency.
Bad example:
GROUP BY TransactionID
Good example:
GROUP BY Region
DP-700 Exam Tips
Remember the following:
GROUP BY creates logical groups before aggregation.
Note that there are 10 practice questions (with answers) at the end of each section to help you solidify your knowledge of the material. Also, there are 2 practice tests with 60 questions each available from the hub's main page below the exam topics section.
Introduction
As organizations adopt Microsoft Fabric, the number of available data assets can grow rapidly. Data engineers, analysts, business users, and executives may encounter hundreds or even thousands of reports, semantic models, dashboards, warehouses, lakehouses, notebooks, and other data assets.
A common challenge is determining:
Which data assets are trustworthy?
Which reports should be used for executive reporting?
Which semantic models represent official business definitions?
Which datasets have been reviewed and approved?
To address these governance challenges, Microsoft Fabric supports endorsements.
Endorsements help organizations identify trusted and authoritative data assets, making it easier for users to discover and use approved content.
For the DP-700 exam, it is important to understand endorsement types, governance benefits, use cases, and how endorsements differ from security and sensitivity labels.
What Are Endorsements?
An endorsement is a governance feature that allows organizations to identify and promote trusted data assets.
Endorsements help users answer the question:
“Can I trust this data asset?”
Instead of searching through numerous reports and datasets, users can quickly identify endorsed items that have been reviewed and approved.
Purpose of Endorsements
Organizations use endorsements to:
Improve data discoverability
Promote trusted assets
Reduce duplicate reports
Encourage consistent reporting
Improve governance
Increase user confidence
Establish authoritative data sources
Endorsement Types
Microsoft Fabric supports two primary endorsement levels:
Promoted
Certified
These endorsement levels indicate different degrees of trust and governance.
Promoted Items
A Promoted item indicates:
The content creator believes the item is valuable.
The item is recommended for broader use.
The item may not have gone through formal governance review.
Think of Promoted as:
Recommended Content
Examples:
Frequently used reports
Department dashboards
Common semantic models
Team-approved datasets
Characteristics of Promoted Items
Promoted items:
Are easier to discover
Indicate useful content
Can be designated by authorized users
Do not necessarily represent official organizational standards
Example
A Sales team creates a dashboard used by dozens of users.
The dashboard is reliable and widely used.
The owner marks it as:
Promoted
This helps users identify it as recommended content.
Certified Items
Certified is a higher endorsement level.
Certified items have typically undergone formal review and approval processes.
Think of Certified as:
Official Trusted Content
Examples:
Executive reporting datasets
Enterprise semantic models
Corporate KPI reports
Official financial dashboards
Characteristics of Certified Items
Certified items:
Represent authoritative data
Follow governance standards
Have undergone validation
Are approved by designated governance teams
Should be used whenever possible
Example
A Finance semantic model contains:
Revenue
Expenses
Profit
Corporate KPIs
The governance team validates the model and certifies it.
The model becomes:
Certified
Users now know it represents official business definitions.
Comparing Promoted and Certified
Feature
Promoted
Certified
Recommended by creator
Yes
Yes
Formal review required
No
Yes
Governance approval
Optional
Required
Official organizational source
Not necessarily
Yes
Highest trust level
No
Yes
Why Endorsements Matter
Without endorsements:
Sales Report V1
Sales Report V2
Sales Report Final
Sales Report Final2
Sales Dashboard New
Users may not know which asset to trust.
With endorsements:
Sales Dashboard
(Certified)
The preferred asset becomes obvious.
Supported Fabric Items
Endorsements can be applied to many Fabric assets, including:
Semantic Models
Reports
Dashboards
Data Warehouses
Lakehouses
Dataflows
Other supported Fabric artifacts
Supported item types may evolve as Microsoft Fabric continues to expand.
Endorsements and Data Discovery
One major benefit of endorsements is improved discoverability.
Users searching for assets can identify:
Promoted content
Certified content
This reduces confusion and encourages reuse of trusted assets.
Governance Benefits
Endorsements support governance initiatives by helping organizations:
Establish trusted data sources
Reduce shadow analytics
Minimize duplicate content
Improve reporting consistency
Promote enterprise standards
Endorsements vs Security Permissions
A common DP-700 exam topic is distinguishing endorsements from security.
Endorsements
Permissions
Identify trusted content
Control access
Governance feature
Security feature
Improve discoverability
Restrict usage
Indicate quality
Grant authorization
Example:
A report may be:
Certified
But users still require permissions to access it.
Certification does not grant access.
Endorsements vs Sensitivity Labels
Another frequently tested distinction.
Endorsements
Sensitivity Labels
Indicate trustworthiness
Indicate sensitivity
Governance and quality
Classification and protection
Help users find trusted content
Help users identify sensitive content
Example:
Certified Report
Highly Confidential
Both labels may exist simultaneously.
The report is:
Trusted (Certified)
Sensitive (Highly Confidential)
Endorsements vs Data Lineage
Endorsements
Data Lineage
Indicates trust
Shows data flow
Governance tool
Dependency tracking tool
Data lineage answers:
Where did this data come from?
Endorsements answer:
Can I trust this asset?
Common DP-700 Exam Scenarios
Scenario 1
Requirement:
Users need to identify official KPI definitions.
Solution:
Use Certified semantic models.
Scenario 2
Requirement:
A department wants to recommend a dashboard without formal review.
Solution:
Use Promoted endorsement.
Scenario 3
Requirement:
An executive dashboard has been validated by the governance team.
Solution:
Apply Certified endorsement.
Scenario 4
Requirement:
A report contains highly sensitive financial information.
Solution:
Apply a sensitivity label.
Not an endorsement.
Endorsement Workflow
A common governance workflow:
Create Asset
↓
Validate Asset
↓
Promote Asset
↓
Governance Review
↓
Certify Asset
This process improves trust and consistency.
Best Practices
Certify Enterprise Assets
Certify:
Corporate KPI datasets
Financial reports
Enterprise semantic models
Promote Useful Content
Promote:
Department dashboards
Frequently used reports
Shared analytics assets
Establish Governance Processes
Define:
Who can certify content
Review procedures
Approval standards
Avoid Certifying Everything
Certification should remain meaningful and reserved for truly authoritative assets.
Combine Governance Features
Use endorsements alongside:
Sensitivity labels
Lineage tracking
Security permissions
Data cataloging
DP-700 Exam Focus Areas
You should understand:
✓ Purpose of endorsements
✓ Promoted endorsements
✓ Certified endorsements
✓ Governance benefits
✓ Data discovery improvements
✓ Trusted data sources
✓ Promoted versus Certified
✓ Endorsements versus permissions
✓ Endorsements versus sensitivity labels
✓ Endorsements versus lineage
✓ Common governance scenarios
Practice Exam Questions
Question 1
What is the primary purpose of endorsements in Microsoft Fabric?
A. Encrypt sensitive data
B. Identify trusted and recommended data assets
C. Filter rows of data
D. Control workspace permissions
Answer: B
Explanation
Endorsements help users identify trusted, recommended, and authoritative data assets within Fabric.
Question 2
Which endorsement level represents the highest level of organizational trust?
A. Endorsed
B. Promoted
C. Confidential
D. Certified
Answer: D
Explanation
Certified is the highest endorsement level and indicates formal governance review and approval.
Question 3
A department wants to highlight a useful dashboard without requiring formal governance approval.
Which endorsement should be used?
A. Certified
B. Promoted
C. Confidential
D. Restricted
Answer: B
Explanation
Promoted endorsements indicate recommended content without requiring formal certification processes.
Question 4
What is a key characteristic of a Certified item?
A. It automatically grants workspace access.
B. It is encrypted.
C. It automatically receives a sensitivity label.
D. It has undergone formal validation and approval.
Answer: D
Explanation
Certified items have been reviewed and approved according to organizational governance standards.
Question 5
How do endorsements differ from security permissions?
A. Endorsements classify sensitivity levels.
B. Endorsements indicate trustworthiness, while permissions control access.
C. Endorsements encrypt content.
D. Endorsements implement Row-Level Security.
Answer: B
Explanation
Permissions determine who can access an asset, while endorsements indicate whether the asset is trusted.
Question 6
Which statement about Promoted items is correct?
A. They require formal governance certification.
B. They cannot be used by business users.
C. They indicate content that is recommended for broader use.
D. They automatically become Certified after publication.
Answer: C
Explanation
Promoted items highlight useful and recommended content without formal certification requirements.
Question 7
A governance team reviews and approves an enterprise semantic model that contains official KPI definitions.
Which endorsement should be applied?
A. Public
B. Promoted
C. Internal
D. Certified
Answer: D
Explanation
Certified endorsement is appropriate for formally reviewed and approved enterprise assets.
Question 8
What problem do endorsements primarily help solve?
A. Unauthorized access
B. Data encryption
C. User identification
D. Difficulty identifying trusted content
Answer: D
Explanation
Endorsements help users distinguish trusted assets from numerous available reports and datasets.
Question 9
A report is marked as Certified.
What does this indicate?
A. It is an authoritative and approved data asset.
B. It is automatically encrypted.
C. It is accessible to all users.
D. It contains confidential information.
Answer: A
Explanation
Certification indicates that the asset has been validated and approved as a trusted source.
Question 10
Which statement best describes the relationship between endorsements and sensitivity labels?
A. They are identical governance features.
B. Sensitivity labels replace endorsements.
C. Endorsements indicate trustworthiness, while sensitivity labels indicate data sensitivity.
D. Certified items cannot have sensitivity labels.
Answer: C
Explanation
Endorsements focus on trust and quality, while sensitivity labels focus on classification and protection requirements.
Exam Tip
One of the most common DP-700 exam traps is confusing endorsements, sensitivity labels, and security permissions.
Remember:
Requirement
Solution
Identify trusted content
Endorsements
Classify sensitive data
Sensitivity Labels
Control who can access data
Permissions
Track data origins
Lineage
A useful memory aid is:
Promoted = Recommended
Certified = Official
Sensitivity Label = Sensitive
Permission = Access
If the exam question focuses on helping users identify the most trustworthy or authoritative asset, the correct answer is often Promoted or Certified endorsement, not a security control.
Note that there are 10 practice questions (with answers) at the end of each section to help you solidify your knowledge of the material. Also, there are 2 practice tests with 60 questions each available from the hub's main page below the exam topics section.
Introduction
Data is one of an organization’s most valuable assets, and not all data carries the same level of sensitivity. Some information can be shared broadly across the organization, while other information must be protected due to regulatory, legal, contractual, or business requirements.
Examples include:
Financial reports
Employee records
Customer information
Healthcare data
Intellectual property
Confidential business plans
Microsoft Fabric integrates with Microsoft Information Protection (MIP) and Microsoft Purview sensitivity labels, enabling organizations to classify and protect data assets throughout their lifecycle.
Sensitivity labels help users understand the importance of data, enforce governance policies, and support compliance initiatives. They can be applied to many Fabric items, including reports, semantic models, dashboards, and other assets.
For the DP-700 exam, it is important to understand what sensitivity labels are, how they work, how they are applied, and how they differ from other security mechanisms such as Row-Level Security (RLS), Object-Level Security (OLS), and workspace permissions.
What Are Sensitivity Labels?
A sensitivity label is a classification tag that identifies the sensitivity level of data or content.
Examples include:
Label
Typical Meaning
Public
Safe for general sharing
General
Internal business use
Confidential
Restricted business information
Highly Confidential
Highly sensitive information
Restricted
Maximum protection required
Organizations can create custom sensitivity labels to align with their governance policies.
Purpose of Sensitivity Labels
Sensitivity labels help organizations:
Classify data consistently
Protect sensitive information
Improve data governance
Support regulatory compliance
Enable data discovery
Increase user awareness
Reduce accidental data exposure
Sensitivity labels serve as both a classification mechanism and, in some scenarios, a protection mechanism.
Sensitivity Labels in Microsoft Fabric
Microsoft Fabric integrates with Microsoft Purview Information Protection.
This integration allows labels to be applied to Fabric assets and propagated through data workflows.
Examples of Fabric items that can support sensitivity labels include:
Reports
Semantic Models
Dashboards
Data Warehouses
Lakehouses
Notebooks
Dataflows
Other supported Fabric artifacts
How Sensitivity Labels Work
A sensitivity label is associated with an item.
Example:
Executive Financial Report
Label: Highly Confidential
Users accessing the item can immediately identify its classification level.
The label travels with the item and may also propagate to downstream artifacts depending on organizational policies and supported scenarios.
Common Sensitivity Label Classifications
Public
Data intended for unrestricted access.
Examples:
Public website content
Marketing brochures
Published documentation
General
Data intended for internal use.
Examples:
Departmental reports
Internal project tracking
Confidential
Data requiring controlled access.
Examples:
Financial reports
Customer information
Internal analytics
Highly Confidential
Data requiring strict protection.
Examples:
Payroll information
Acquisition plans
Executive strategy documents
Restricted
Data requiring maximum protection.
Examples:
Legal investigations
Security credentials
Highly regulated information
Applying Sensitivity Labels
Sensitivity labels can be applied manually or automatically depending on organizational configurations.
Manual Labeling
Users select the appropriate label.
Example:
Report
↓
Apply Label
↓
Confidential
Manual labeling is commonly used when users understand the business context of the data.
Automatic Labeling
Organizations may configure policies that automatically apply labels based on:
Sensitive information types
Data patterns
Business rules
Compliance requirements
Example:
Contains Credit Card Data
↓
Apply Highly Confidential
Label Inheritance and Propagation
One of the most important DP-700 exam topics related to sensitivity labels is inheritance.
Labels may propagate from source items to downstream artifacts.
Example:
Lakehouse
(Confidential)
↓
Semantic Model
↓
Report
The downstream item may inherit the sensitivity label from its source.
This helps maintain governance consistency throughout the analytics lifecycle.
Benefits of Label Propagation
Without propagation:
Sensitive Data
↓
Unlabeled Report
Risk:
Users may unknowingly share sensitive information.
With propagation:
Sensitive Data
↓
Confidential Report
Users are immediately aware of the sensitivity level.
Sensitivity Labels vs Security Permissions
This distinction is frequently tested on certification exams.
Sensitivity Labels
Security Permissions
Classify data
Control access
Provide governance context
Enforce authorization
Improve awareness
Restrict usage
Support compliance
Protect resources
Example:
A report may be labeled:
Highly Confidential
But unless appropriate permissions exist, the label alone does not automatically prevent access.
Sensitivity Labels vs Row-Level Security
Sensitivity Labels
Row-Level Security
Classify content
Filter data rows
Governance feature
Access control feature
Applies to items
Applies to data records
Example:
RLS:
East Manager
↓
East Region Rows Only
Sensitivity Label:
Confidential Report
Both can be used together.
Sensitivity Labels vs Dynamic Data Masking
Sensitivity Labels
Dynamic Data Masking
Classifies data
Obscures sensitive values
Governance-focused
Security-focused
Does not change data display
Changes displayed values
Example:
Label:
Highly Confidential
Masking:
XXXX-XXXX-1234
Sensitivity Labels and Compliance
Sensitivity labels play an important role in compliance initiatives such as:
GDPR
HIPAA
PCI DSS
SOX
Internal governance programs
They help organizations:
Identify sensitive assets
Demonstrate governance controls
Improve audit readiness
Sensitivity Labels and Microsoft Purview
Microsoft Purview provides centralized governance capabilities.
Organizations can use Purview to:
Define sensitivity labels
Publish labels
Manage classification policies
Track protected content
Support compliance reporting
Fabric integrates with these governance capabilities.
Real-World Scenarios
Scenario 1
A finance report contains quarterly earnings information.
Solution:
Apply a Confidential sensitivity label.
Scenario 2
A payroll dataset contains salary and compensation data.
Solution:
Apply a Highly Confidential sensitivity label.
Scenario 3
A public product catalog is intended for external customers.
Solution:
Apply a Public label.
Scenario 4
A report inherits data from a Confidential semantic model.
Result:
The report may inherit the Confidential label through label propagation.
Best Practices
Establish a Clear Classification Framework
Create standardized labels such as:
Public
General
Confidential
Highly Confidential
Use Consistent Labeling
Apply labels consistently across Fabric assets.
Leverage Label Propagation
Allow downstream artifacts to inherit labels when appropriate.
Train Users
Ensure users understand:
Label meanings
Sharing responsibilities
Governance requirements
Combine Labels with Security Controls
Use labels alongside:
Workspace permissions
Item permissions
Row-Level Security
Object-Level Security
Dynamic Data Masking
Review Labels Regularly
Data classifications may change over time.
DP-700 Exam Focus Areas
You should understand:
✓ Sensitivity label concepts
✓ Microsoft Purview integration
✓ Classification levels
✓ Manual labeling
✓ Automatic labeling
✓ Label inheritance
✓ Label propagation
✓ Governance benefits
✓ Compliance scenarios
✓ Sensitivity labels versus security permissions
✓ Sensitivity labels versus RLS
✓ Sensitivity labels versus Dynamic Data Masking
Practice Exam Questions
Question 1
What is the primary purpose of a sensitivity label in Microsoft Fabric?
A. To classify and identify the sensitivity level of data
B. To encrypt data at rest
C. To filter rows of data
D. To assign workspace roles
Answer: A
Explanation
Sensitivity labels classify data according to its sensitivity and governance requirements. They are primarily used for data classification and protection awareness.
Question 2
Which Microsoft service provides the sensitivity labeling framework used by Microsoft Fabric?
A. Microsoft Purview
B. Microsoft Defender
C. Microsoft Sentinel
D. Azure Key Vault
Answer: A
Explanation
Microsoft Fabric integrates with Microsoft Purview Information Protection to provide sensitivity labeling capabilities.
Question 3
A company wants reports containing payroll information to be clearly identified as highly sensitive.
Which feature should be used?
A. Dynamic Data Masking
B. Row-Level Security
C. Sensitivity Labels
D. Deployment Pipelines
Answer: C
Explanation
Sensitivity labels classify and identify the sensitivity level of data assets such as payroll reports.
Question 4
What is label propagation?
A. Automatic workspace creation
B. Automatic dataset refresh
C. Automatic role assignment
D. Automatic inheritance of sensitivity labels to downstream items
Answer: D
Explanation
Label propagation helps maintain consistent governance by carrying sensitivity classifications to derived artifacts.
Question 5
Which statement best describes the relationship between sensitivity labels and security permissions?
A. Sensitivity labels replace security permissions.
B. Security permissions automatically create labels.
C. Sensitivity labels classify data, while permissions control access.
D. Sensitivity labels filter rows of data.
Answer: C
Explanation
Labels provide classification and governance context, while permissions determine who can access resources.
Question 6
A report inherits data from a semantic model labeled Confidential.
What may happen if label propagation is enabled?
A. The report may inherit the Confidential label.
B. The report becomes encrypted automatically.
C. The report is deleted after publication.
D. Workspace permissions are removed.
Answer: A
Explanation
Label propagation can automatically apply inherited classifications to downstream assets.
Question 7
Which classification would generally represent the highest level of protection?
A. Public
B. General
C. Confidential
D. Highly Confidential
Answer: D
Explanation
Highly Confidential labels are typically used for the most sensitive business information.
Question 8
Which statement about sensitivity labels is correct?
A. They filter records based on user identity.
B. They hide columns from users.
C. They help classify and govern data assets.
D. They assign workspace roles.
Answer: C
Explanation
Sensitivity labels primarily support classification, governance, and compliance initiatives.
Question 9
A company wants to automatically classify files containing credit card information.
Which capability supports this requirement?
A. Automatic sensitivity labeling
B. Dynamic Data Masking
C. Workspace Viewer permissions
D. Object-Level Security
Answer: A
Explanation
Automatic labeling policies can identify sensitive information patterns and apply appropriate labels.
Question 10
Why should sensitivity labels be combined with security controls?
A. Labels automatically replace encryption.
B. Labels alone do not control access to data.
C. Labels remove the need for governance policies.
D. Labels prevent all data leakage scenarios.
Answer: B
Explanation
Sensitivity labels provide classification and governance information, but access controls such as permissions, RLS, and masking are still required to secure data.
Exam Tip
A common DP-700 exam challenge is distinguishing classification technologies from access control technologies.
Remember:
Requirement
Solution
Classify data sensitivity
Sensitivity Labels
Restrict who can access data
Permissions
Restrict which rows users see
Row-Level Security
Hide sensitive values
Dynamic Data Masking
Hide tables or objects
Object-Level Security
If the question focuses on identifying, classifying, labeling, governing, or tracking sensitive data, the correct answer is often Sensitivity Labels rather than a traditional security control.
Note that there are 10 practice questions (with answers) at the end of each section to help you solidify your knowledge of the material. Also, there are 2 practice tests with 60 questions each available from the hub's main page below the exam topics section.
Introduction
Protecting sensitive data is a critical responsibility for data engineers. Organizations routinely store confidential information such as:
Personally Identifiable Information (PII)
Social Security numbers
Credit card information
Email addresses
Phone numbers
Employee salaries
Customer account details
While some users require access to this information, many others only need access to the surrounding business data. Granting unrestricted visibility to sensitive values can increase security risks and create compliance concerns.
Dynamic Data Masking (DDM) is a security feature that limits the exposure of sensitive data by masking values for non-privileged users while allowing authorized users to see the original values.
For the DP-700 exam, it is important to understand how Dynamic Data Masking works, its use cases, limitations, and how it differs from other security mechanisms such as Row-Level Security (RLS), Column-Level Security (CLS), and encryption.
What Is Dynamic Data Masking?
Dynamic Data Masking is a security feature that obscures sensitive data at query time.
The actual data remains unchanged in storage.
Instead, unauthorized users see a masked version of the data.
This post is a part of the DP-700: Implementing Data Engineering Solutions Using Microsoft Fabric Exam Prep Hub. This topic falls under these sections: Implement and manage an analytics solution (30–35%) --> Configure security and governance --> Implement row-level, column-level, object-level, and folder/file-level access controls
Note that there are 10 practice questions (with answers) at the end of each section to help you solidify your knowledge of the material. Also, there are 2 practice tests with 60 questions each available from the hub's main page below the exam topics section.
Introduction
Modern data platforms must secure information at multiple layers. While workspace-level and item-level permissions determine who can access Fabric assets, organizations often require much more granular control over the data itself.
For example:
A regional sales manager should only see sales data for their region.
Human Resources staff should see salary information, while other users should not.
Analysts should access specific tables but not highly sensitive tables.
Data engineers should have access to specific folders within OneLake while being restricted from others.
Microsoft Fabric supports multiple layers of security to address these requirements:
Row-Level Security (RLS)
Column-Level Security (CLS)
Object-Level Security (OLS)
Folder/File-Level Security
These controls help organizations implement the Principle of Least Privilege while supporting regulatory compliance, governance requirements, and data protection initiatives.
For the DP-700 exam, understanding the differences between these security mechanisms and when to use each one is extremely important.
Understanding Security Layers
Security in Fabric is often implemented as multiple layers.
Workspace Security
↓
Item Security
↓
Row-Level Security
↓
Column-Level Security
↓
Object-Level Security
↓
Folder/File Security
Each layer controls access to increasingly granular portions of data.
Row-Level Security (RLS)
What Is Row-Level Security?
Row-Level Security restricts which rows of data a user can view.
Users access the same table or report but see different subsets of data.
Example table:
Employee
Region
Sales
John
East
100,000
Sarah
West
150,000
Mike
East
120,000
With RLS:
User
Visible Data
East Manager
East rows only
West Manager
West rows only
Why Use RLS?
Organizations commonly use RLS to:
Restrict regional data
Secure department-specific data
Support multi-tenant solutions
Enforce business ownership boundaries
Static RLS
Static RLS uses predefined security roles.
Example:
Region = "East"
Users assigned to the role see only East region data.
Dynamic RLS
Dynamic RLS evaluates the currently logged-in user.
Example:
USERPRINCIPALNAME()
The system automatically determines which rows the user should access.
Dynamic RLS is commonly used in enterprise implementations because it scales better than manually assigning users to roles.
Common DP-700 RLS Scenario
A company has regional managers.
Requirement:
Each manager should only see data for their assigned region.
Solution:
Implement Row-Level Security.
Column-Level Security (CLS)
What Is Column-Level Security?
Column-Level Security restricts access to specific columns while allowing access to the rest of the table.
Example table:
EmployeeID
Name
Salary
1001
John
90,000
1002
Sarah
110,000
With CLS:
HR Users:
EmployeeID
Name
Salary
1001
John
90,000
Non-HR Users:
EmployeeID
Name
1001
John
The Salary column is hidden.
Why Use CLS?
CLS is commonly used to protect:
Salary information
Personally identifiable information (PII)
Social Security numbers
Healthcare data
Financial account information
Benefits of CLS
Protects sensitive fields
Simplifies compliance efforts
Reduces data exposure
Supports privacy regulations
Common DP-700 CLS Scenario
Requirement:
Managers need employee information but must not see salary data.
Solution:
Implement Column-Level Security.
Object-Level Security (OLS)
What Is Object-Level Security?
Object-Level Security controls access to entire database objects.
Examples include:
Tables
Views
Columns
Measures
Rather than filtering data, OLS completely hides objects from users.
Example
Database Objects:
Sales Table
Customer Table
Payroll Table
Finance Users:
Sales Table
Customer Table
Payroll Table
Sales Users:
Sales Table
Customer Table
The Payroll table is completely hidden.
OLS vs CLS
This distinction is frequently tested on the DP-700 exam.
Feature
CLS
OLS
Hides columns
Yes
Yes
Hides tables
No
Yes
Hides measures
No
Yes
Hides entire objects
No
Yes
Why Use OLS?
Organizations use OLS when users should not even know an object exists.
Examples:
Payroll tables
Executive compensation data
Audit tables
Compliance datasets
Common DP-700 OLS Scenario
Requirement:
Analysts should not see the Payroll table at all.
Solution:
Implement Object-Level Security.
Folder-Level Security
What Is Folder-Level Security?
Folder-level security controls access to folders within storage structures such as OneLake.
Example:
Finance
│
├── Payroll
├── Budgets
└── Forecasts
Sales
│
├── Regional
└── Territory
Finance users may access:
Finance/*
while Sales users may access:
Sales/*
Why Folder-Level Security Matters
Benefits include:
Departmental separation
Data governance
Simplified access management
Better organization
OneLake Considerations
Microsoft Fabric’s OneLake serves as the unified storage layer.
Organizations often structure OneLake data using:
Department
↓
Project
↓
Files
Folder-level controls help restrict access appropriately.
File-Level Security
What Is File-Level Security?
File-level security controls access to individual files.
Example:
EmployeeData.parquet
Payroll.parquet
Benefits.parquet
A user may be granted access to:
EmployeeData.parquet
while being denied access to:
Payroll.parquet
Use Cases
File-level security is useful when:
Sensitive files exist within shared folders
Regulatory restrictions apply
Individual datasets require additional protection
Folder-Level vs File-Level Security
Folder Security
File Security
Controls entire folder
Controls individual files
Easier to manage
More granular
Less administrative effort
Greater precision
Comparing All Four Security Models
Security Type
Controls
Row-Level Security
Which rows users can see
Column-Level Security
Which columns users can see
Object-Level Security
Which tables, views, measures, or columns exist for users
Folder/File Security
Which storage locations users can access
Security Layer Examples
Example 1: Regional Sales
Requirement:
Users should only see sales for their region.
Solution:
Row-Level Security
Example 2: Salary Protection
Requirement:
Users can see employee records but not salary information.
Solution:
Column-Level Security
Example 3: Payroll Table Protection
Requirement:
Payroll tables should be invisible to most users.
Solution:
Object-Level Security
Example 4: Departmental Data Separation
Requirement:
Finance files should not be accessible by Sales users.
Solution:
Folder-Level Security
Combining Security Controls
Enterprise environments often combine multiple controls.
Example:
Workspace Permission
↓
Item Permission
↓
RLS
↓
CLS
↓
OLS
↓
Folder Security
This layered approach provides stronger protection.
Best Practices
Follow Least Privilege
Grant only required access.
Prefer Dynamic RLS
Dynamic RLS scales better than manually maintained security roles.
Use OLS for Highly Sensitive Objects
Hide entire tables when appropriate.
Protect Sensitive Columns
Use CLS for PII and confidential information.
Organize OneLake Carefully
Use logical folder structures to simplify governance.
Audit Security Regularly
Review permissions and security configurations periodically.
DP-700 Exam Focus Areas
You should understand:
✓ Row-Level Security (RLS)
✓ Static versus Dynamic RLS
✓ Column-Level Security (CLS)
✓ Object-Level Security (OLS)
✓ Folder-level access controls
✓ File-level access controls
✓ OneLake security concepts
✓ Security layering
✓ Least-privilege principles
✓ Common security implementation scenarios
Practice Exam Questions
Question 1
A company wants regional managers to see only sales records from their assigned region.
Which security feature should be implemented?
A. File-Level Security
B. Object-Level Security
C. Workspace Security
D. Row-Level Security
Answer: D
Explanation
Row-Level Security filters rows based on user identity or role, allowing managers to view only relevant regional data.
Question 2
A user should be able to view employee records but not salary information.
Which security feature should be used?
A. Row-Level Security
B. Workspace Viewer Role
C. Column-Level Security
D. Deployment Rules
Answer: C
Explanation
Column-Level Security restricts access to specific columns while allowing access to the rest of the table.
Question 3
Which security feature can completely hide a table from users?
A. Row-Level Security
B. Object-Level Security
C. File-Level Security
D. Workspace Security
Answer: B
Explanation
Object-Level Security can hide entire tables, views, columns, and measures.
Question 4
A company wants to prevent users from accessing a specific file within a shared OneLake folder.
Which security mechanism is most appropriate?
A. Row-Level Security
B. Column-Level Security
C. Object-Level Security
D. File-Level Security
Answer: D
Explanation
File-Level Security controls access to individual files.
Question 5
What is a key advantage of Dynamic RLS compared to Static RLS?
A. Faster query execution
B. Automatically adjusts security based on the logged-in user
C. Eliminates the need for semantic models
D. Removes workspace permissions
Answer: B
Explanation
Dynamic RLS uses user identity functions to determine appropriate data access automatically.
Question 6
Which security control is best suited for hiding a Payroll table from analysts?
A. Column-Level Security
B. Folder-Level Security
C. Object-Level Security
D. Row-Level Security
Answer: C
Explanation
OLS completely hides the table from unauthorized users.
Question 7
A company wants Finance users to access the Finance folder but not the Sales folder.
Which security mechanism should be implemented?
A. Folder-Level Security
B. Row-Level Security
C. Column-Level Security
D. Build Permission
Answer: A
Explanation
Folder-Level Security restricts access to specific storage locations.
Question 8
Which statement correctly describes Column-Level Security?
A. It filters rows of data.
B. It hides specific columns while keeping the table accessible.
C. It hides entire tables.
D. It controls workspace membership.
Answer: B
Explanation
CLS allows access to the table while restricting access to designated columns.
Question 9
What is the primary purpose of Object-Level Security?
A. Filter data rows
B. Control notebook execution
C. Hide entire data objects from users
D. Manage workspace permissions
Answer: C
Explanation
OLS controls visibility of tables, views, columns, and measures.
Question 10
Which combination provides the most granular data protection?
A. Workspace Security only
B. Workspace Security and Item Security only
C. Row-Level Security only
D. Layered security using RLS, CLS, OLS, and folder/file controls
Answer: D
Explanation
Layering multiple security mechanisms provides comprehensive protection across multiple levels of the data platform.
Exam Tip
For the DP-700 exam, remember these distinctions:
Requirement
Solution
Restrict specific records
Row-Level Security (RLS)
Hide specific columns
Column-Level Security (CLS)
Hide entire tables, views, or measures
Object-Level Security (OLS)
Restrict storage locations
Folder/File-Level Security
A common exam strategy is to identify what is being protected:
Rows → RLS
Columns → CLS
Objects (tables/views/measures) → OLS
Files/Folders → Folder/File-Level Security
Many DP-700 questions present multiple security options that seem plausible. Focusing on the exact scope of the restriction usually leads directly to the correct answer.
This post is a part of the DP-700: Implementing Data Engineering Solutions Using Microsoft Fabric Exam Prep Hub. This topic falls under these sections: Implement and manage an analytics solution (30–35%) --> Configure security and governance --> Implement item-level access controls
Note that there are 10 practice questions (with answers) at the end of each section to help you solidify your knowledge of the material. Also, there are 2 practice tests with 60 questions each available from the hub's main page below the exam topics section.
Introduction
While workspace-level permissions provide the first layer of security in Microsoft Fabric, they are often not sufficient for enterprise environments. Organizations frequently need to grant users access to specific assets without providing access to everything within a workspace.
This is where item-level access controls become important.
Item-level access controls allow administrators and data engineers to secure individual Fabric items such as Lakehouses, Warehouses, Semantic Models, Reports, Dashboards, and other assets. These controls provide more granular security than workspace permissions and help organizations implement governance, compliance, and least-privilege access models.
For the DP-700 exam, it is important to understand how item-level permissions work, how they interact with workspace permissions, and when to use item-level controls instead of workspace-level access.
What Are Item-Level Access Controls?
Item-level access controls are permissions assigned directly to specific Fabric assets rather than to an entire workspace.
For example:
Workspace
│
├── Lakehouse A
├── Lakehouse B
├── Warehouse A
├── Warehouse B
└── Notebook A
A user might need access only to:
Lakehouse A
Warehouse A
without gaining access to the entire workspace.
Item-level permissions make this possible.
Why Item-Level Security Is Important
Many organizations have:
Sensitive financial data
Human resources data
Customer information
Regulatory data
Executive reporting data
Providing broad workspace access could expose data unnecessarily.
Item-level controls allow organizations to:
Restrict sensitive assets
Share specific content
Improve governance
Support compliance requirements
Implement least-privilege security
Workspace Permissions vs Item-Level Permissions
One of the most frequently tested DP-700 topics is understanding the difference between workspace-level and item-level permissions.
Workspace-Level Access
Item-Level Access
Applies to entire workspace
Applies to specific items
Broader permissions
Granular permissions
Easier administration
More precise security
Used for collaboration
Used for controlled sharing
Example
A data engineer may need:
Contributor access to a workspace
while an executive may only need:
Access to a single report
In this scenario, item-level permissions are the preferred solution.
Permission Inheritance
Understanding inheritance is critical for the DP-700 exam.
Workspace permissions often provide access to contained items.
However, item-level permissions can be used to:
Grant access beyond workspace membership
Share specific assets
Restrict access to sensitive content
Exam Tip
Many questions focus on determining whether workspace-level permissions or item-level permissions should be used.
A good rule is:
Access to many assets → Workspace permissions
Access to one or a few assets → Item-level permissions
Item-Level Security for Lakehouses
Lakehouses contain:
Delta tables
Files
Structured data
Unstructured data
Organizations often need to control who can access these assets.
Examples include:
Finance Lakehouse
HR Lakehouse
Customer Analytics Lakehouse
Item-level permissions can limit access to specific Lakehouses without exposing all workspace assets.
Item-Level Security for Warehouses
Fabric Data Warehouses frequently contain business-critical data.
Examples include:
Sales metrics
Financial transactions
Customer information
Warehouse permissions can be assigned independently of workspace permissions.
This helps organizations:
Restrict data access
Support regulatory requirements
Enforce data ownership
Item-Level Security for Reports
Reports are one of the most commonly shared Fabric assets.
A user may need:
Access to a report
No access to development artifacts
Examples:
Executive dashboards
Department reports
Operational reporting
Item-level sharing enables this scenario.
Semantic Model Permissions
Semantic Models serve as the foundation for many reporting solutions.
Permissions can control who may:
View the model
Build reports from the model
Query the model
Common permissions include:
Read access
Build permission
Understanding Build Permission
Build permission is a commonly tested Fabric security topic.
Users with Build permission can:
Create reports from a semantic model
Analyze data using approved tools
Reuse trusted datasets
Without Build permission, users may be able to view reports but not create new reports from the underlying semantic model.
Example
Semantic Model
↓
Build Permission
↓
Create New Reports
This distinction frequently appears in exam questions.
Sharing Items
Fabric allows users to share individual assets.
Examples include:
Reports
Semantic Models
Dashboards
Sharing provides targeted access without adding users to the workspace.
Benefits include:
Reduced administrative overhead
Improved security
Easier collaboration
Row-Level Security (RLS)
Although RLS is often discussed separately from item permissions, it is closely related to access control.
Row-Level Security restricts which rows a user can view.
Example:
User
Visible Region
Alice
East
Bob
West
Both users access the same report but see different data.
Important Distinction
Item-level permissions control:
Who can access the item
RLS controls:
What data they can see within the item
This distinction is commonly tested.
Object-Level Security (OLS)
Object-Level Security provides even more granular control.
OLS can restrict access to:
Tables
Columns
Measures
Example:
Finance users:
Salary Column = Visible
General users:
Salary Column = Hidden
Combining Security Layers
Enterprise security often combines:
Workspace Security
↓
Item Security
↓
Row-Level Security
↓
Object-Level Security
Each layer provides additional protection.
Security Groups and Item Permissions
Best practice is to assign item permissions through Microsoft Entra ID groups rather than individual users.
Example:
Finance Executives Group
↓
Executive Dashboard Access
Benefits include:
Easier administration
Consistent security
Simplified auditing
Common DP-700 Exam Scenarios
Scenario 1
A CEO needs access to a financial dashboard but should not access the entire workspace.
Solution:
Use item-level sharing on the report.
Scenario 2
Analysts need to create reports from a semantic model.
Solution:
Grant Build permission.
Scenario 3
Regional managers should only see sales data for their region.
Solution:
Implement Row-Level Security.
Scenario 4
Users should not see salary-related columns.
Solution:
Implement Object-Level Security.
Best Practices
Follow Least Privilege
Grant only necessary permissions.
Use Security Groups
Avoid assigning permissions to individual users whenever possible.
Use Build Permission Carefully
Build permission enables report creation and data exploration.
Combine Security Layers
Use:
Workspace permissions
Item permissions
RLS
OLS
where appropriate.
Audit Permissions Regularly
Review access assignments periodically.
Secure Sensitive Assets Separately
Finance, HR, and compliance data should receive additional scrutiny.
DP-700 Exam Focus Areas
You should understand:
✓ Item-level permissions
✓ Workspace vs item-level security
✓ Semantic model permissions
✓ Build permission
✓ Report sharing
✓ Lakehouse permissions
✓ Warehouse permissions
✓ Permission inheritance
✓ Row-Level Security (RLS)
✓ Object-Level Security (OLS)
✓ Security group assignments
✓ Least-privilege principles
Practice Exam Questions
Question 1
A user needs access to a single report but should not have access to the workspace.
What should be used?
A. Workspace Admin role
B. Workspace Member role
C. Item-level sharing
D. Capacity assignment
Answer: C
Explanation
Item-level sharing allows access to a specific report without granting workspace access.
Question 2
What is the primary purpose of item-level access controls?
A. Manage Fabric capacities
B. Secure specific Fabric assets
C. Configure deployment pipelines
D. Manage Spark pools
Answer: B
Explanation
Item-level permissions provide granular security for individual Fabric items.
Question 3
Which permission allows users to create reports from an existing semantic model?
A. Viewer
B. Contributor
C. Read
D. Build
Answer: D
Explanation
Build permission allows users to create new reports and analyses from a semantic model.
Question 4
A user can access a report but should only see rows for their assigned sales region.
Which security feature should be implemented?
A. Item sharing
B. Workspace Viewer role
C. Object-Level Security
D. Row-Level Security
Answer: D
Explanation
Row-Level Security filters data based on user identity or role.
Question 5
What is the primary difference between workspace-level and item-level permissions?
A. Item-level permissions apply to specific assets
B. Workspace permissions only apply to reports
C. Item permissions control Spark resources
D. Workspace permissions cannot be assigned to groups
Answer: A
Explanation
Workspace permissions affect the entire workspace, while item-level permissions affect specific assets.
Question 6
A company wants users to access an executive dashboard without viewing development notebooks.
What should be implemented?
A. Workspace Admin access
B. Workspace Contributor access
C. Item-level access to the dashboard
D. Capacity permissions
Answer: C
Explanation
Item-level sharing allows access to specific assets without exposing the broader workspace.
Question 7
What does Object-Level Security (OLS) control?
A. Workspace membership
B. Data refresh schedules
C. Deployment permissions
D. Access to tables, columns, and measures
Answer: D
Explanation
OLS provides granular security at the database object level.
Question 8
A user belongs to a workspace but should not access a highly sensitive financial warehouse.
What security approach is most appropriate?
A. Use item-level controls on the warehouse
B. Increase capacity
C. Configure deployment rules
D. Create a notebook
Answer: A
Explanation
Item-level permissions provide additional control over access to sensitive assets.
Question 9
Which statement about Build permission is correct?
A. It grants workspace administration rights.
B. It allows users to create reports from a semantic model.
C. It controls deployment pipelines.
D. It replaces Row-Level Security.
Answer: B
Explanation
Build permission enables report creation and data exploration based on a semantic model.
Question 10
What is considered a best practice when assigning item-level permissions?
A. Assign permissions directly to every user
B. Use only Admin roles
C. Use Microsoft Entra ID groups
D. Disable item sharing
Answer: C
Explanation
Group-based permission management improves consistency, scalability, and governance.
Exam Tip
For the DP-700 exam, remember the following hierarchy:
Security Layer
Purpose
Workspace Security
Controls access to the workspace
Item-Level Security
Controls access to specific assets
Row-Level Security (RLS)
Controls which rows users can see
Object-Level Security (OLS)
Controls which tables, columns, or measures users can access
A common exam strategy is to identify whether the question is asking who can access an asset (item permissions) or what data they can see after gaining access (RLS/OLS). This distinction often leads directly to the correct answer.
This post is a part of the DP-700: Implementing Data Engineering Solutions Using Microsoft Fabric Exam Prep Hub. This topic falls under these sections: Implement and manage an analytics solution (30–35%) --> Configure security and governance --> Implement workspace-level access controls
Note that there are 10 practice questions (with answers) at the end of each section to help you solidify your knowledge of the material. Also, there are 2 practice tests with 60 questions each available from the hub's main page below the exam topics section.
Introduction
Security and governance are foundational components of any enterprise analytics platform. In Microsoft Fabric, workspaces serve as the primary organizational boundary for managing content, collaboration, and permissions. Because workspaces often contain sensitive data assets such as Lakehouses, Warehouses, Data Pipelines, Notebooks, and Reports, controlling who can access and modify these assets is critical.
Workspace-level access controls provide the first layer of security within Fabric. They determine who can view, create, modify, share, and administer workspace content. Properly configured access controls help organizations implement the principle of least privilege, improve governance, reduce security risks, and ensure compliance with organizational policies.
For the DP-700 exam, you should understand workspace roles, permission inheritance, Microsoft Entra ID integration, security best practices, and common access-control scenarios.
Understanding Fabric Workspaces
A workspace is a collaborative environment used to organize and manage Fabric assets.
Examples of assets stored within a workspace include:
Lakehouses
Data Warehouses
Data Pipelines
Dataflows Gen2
Notebooks
Semantic Models
Reports
Eventstreams
Environments
Workspaces serve as the primary security boundary for these resources.
Why Workspace-Level Access Controls Matter
Without proper access controls:
Unauthorized users may access sensitive data.
Critical assets may be modified accidentally.
Governance requirements may not be met.
Production environments may be compromised.
Workspace-level security helps organizations:
Restrict access
Protect sensitive data
Separate responsibilities
Support auditing and compliance
Implement least-privilege security
Microsoft Entra ID Integration
Microsoft Fabric uses Microsoft Entra ID for authentication and identity management.
Users access Fabric using their organizational accounts.
Benefits include:
Centralized identity management
Single sign-on (SSO)
Multi-factor authentication support
Group-based security management
Conditional Access integration
Fabric does not maintain a separate user authentication system.
Workspace Roles
Workspace access is controlled through predefined roles.
The four primary workspace roles are:
Role
Purpose
Admin
Full workspace control
Member
Create, edit, and publish content
Contributor
Create and modify content
Viewer
Read-only access
Understanding these roles is extremely important for the DP-700 exam.
Admin Role
Admins have complete control over the workspace.
Capabilities include:
Manage workspace settings
Add or remove users
Assign roles
Delete workspace content
Configure Git integration
Configure deployment pipelines
Manage permissions
Admins effectively own the workspace.
Use Cases
Platform administrators
Workspace owners
Data engineering leads
Member Role
Members can actively participate in workspace development.
Capabilities include:
Create content
Modify content
Publish content
Collaborate with team members
However, Members do not have all administrative capabilities.
Use Cases
Senior developers
Data engineers
Analytics developers
Contributor Role
Contributors can create and modify content but have fewer management capabilities than Members.
Capabilities include:
Create notebooks
Create pipelines
Modify assets
Build solutions
Contributors generally focus on development activities rather than workspace administration.
Use Cases
Developers
Data engineers
ETL specialists
Viewer Role
Viewers have read-only access.
Capabilities include:
View reports
View data assets
Review content
Restrictions include:
Cannot modify content
Cannot create content
Cannot administer the workspace
Use Cases
Business users
Auditors
Stakeholders
Workspace Permission Assignment
Permissions can be assigned to:
Individual users
Security groups
Microsoft Entra ID groups
Best practice is to assign permissions through groups whenever possible.
Example:
Finance-DataEngineers → Contributor
Finance-Developers → Member
Finance-Managers → Viewer
Benefits include:
Easier administration
Reduced maintenance
Improved consistency
Principle of Least Privilege
One of the most important security concepts for DP-700 is the Principle of Least Privilege.
This principle states:
Users should receive only the permissions necessary to perform their job functions.
Example:
User Type
Recommended Role
Report Consumer
Viewer
Data Engineer
Contributor
Team Lead
Member
Workspace Owner
Admin
Over-permissioning increases security risks.
Permission Inheritance
Workspace-level permissions often provide access to items contained within the workspace.
Examples include:
Lakehouses
Warehouses
Notebooks
Dataflows
A user with workspace access generally gains access to supported content based on their assigned role.
However, some Fabric items support additional item-level permissions that can supplement workspace-level controls.
Exam Tip
Workspace permissions and item-level permissions are related but not identical.
Many exam questions test your understanding of this distinction.
Workspace Access and OneLake
OneLake security is closely tied to Fabric permissions.
When users access:
Lakehouses
Warehouse data
OneLake files
their permissions are generally governed through Fabric security controls.
This means workspace permissions play a significant role in determining data accessibility.
Separating Development, Test, and Production Access
Organizations commonly implement separate workspaces for:
Development
↓
Test
↓
Production
Different access controls are applied to each environment.
Example:
Environment
Typical Permissions
Development
Contributors and Members
Test
Limited Contributors
Production
Mostly Viewers
This reduces the risk of unauthorized production changes.
Workspace Security Best Practices
Use Security Groups
Prefer:
Sales-DataEngineers
instead of assigning permissions to individual users.
Minimize Admins
Only a small number of users should have Admin privileges.
Separate Production Access
Production workspaces should have stricter permissions.
Review Permissions Regularly
Conduct periodic audits of workspace access.
Follow Least Privilege
Assign the lowest role necessary.
Use Dedicated Service Principals
Automated processes should use service principals rather than personal accounts.
Common Security Scenarios
Scenario 1
A business analyst needs to view reports but should not modify content.
Solution:
Assign the Viewer role.
Scenario 2
A data engineer needs to build pipelines and notebooks but should not manage workspace permissions.
Solution:
Assign the Contributor role.
Scenario 3
A workspace owner needs to manage users and configure workspace settings.
Solution:
Assign the Admin role.
Scenario 4
A team lead needs to create and manage content while collaborating with developers.
Solution:
Assign the Member role.
Auditing and Governance
Workspace access controls support governance by enabling:
Access reviews
Compliance reporting
Security audits
Change tracking
Administrators should periodically verify:
User memberships
Group assignments
Admin privileges
Production access
These activities help maintain a secure Fabric environment.
DP-700 Exam Focus Areas
You should understand:
✓ Workspace roles
✓ Admin, Member, Contributor, and Viewer permissions
✓ Microsoft Entra ID integration
✓ Security group assignments
✓ Least-privilege principles
✓ Workspace permission inheritance
✓ Item-level versus workspace-level security
✓ Production environment security
✓ Service principal usage
✓ Governance and auditing practices
Practice Exam Questions
Question 1
Which workspace role provides full control over workspace settings and permissions?
A. Admin
B. Member
C. Contributor
D. Viewer
Answer: A
Explanation
Admins have complete control over workspace management, including permissions, settings, and content administration.
Question 2
A user needs read-only access to reports and data assets in a workspace.
Which role should be assigned?
A. Admin
B. Member
C. Contributor
D. Viewer
Answer: D
Explanation
The Viewer role allows users to access and view content without modifying it.
Question 3
Which Microsoft service provides identity and authentication for Fabric users?
A. Azure Data Lake Storage
B. Microsoft Entra ID
C. OneLake
D. Fabric Capacity
Answer: B
Explanation
Microsoft Entra ID provides authentication, identity management, and access control for Fabric users.
Question 4
A data engineer needs to create notebooks and pipelines but should not manage workspace permissions.
Which role is most appropriate?
A. Viewer
B. Admin
C. Contributor
D. Workspace Owner
Answer: C
Explanation
Contributors can create and modify content without having full administrative privileges.
Question 5
What is the primary goal of the Principle of Least Privilege?
A. Maximize workspace access
B. Reduce storage costs
C. Improve Spark performance
D. Grant only the permissions required to perform a job
Answer: D
Explanation
Least privilege reduces security risks by ensuring users receive only the permissions necessary for their responsibilities.
Question 6
Which approach is generally recommended for assigning workspace permissions?
A. Assign permissions directly to every user
B. Use Microsoft Entra ID security groups
C. Give all users Member access
D. Assign Admin access broadly
Answer: B
Explanation
Group-based permission management simplifies administration and improves consistency.
Question 7
A team lead needs to create content, collaborate with developers, and participate in solution management but does not require full administrative control.
Which role is most appropriate?
A. Viewer
B. Contributor
C. Member
D. Admin
Answer: C
Explanation
Members can actively manage and collaborate on workspace content without having full administrative authority.
Question 8
Why should organizations limit the number of workspace Admins?
A. To reduce Spark resource consumption
B. To simplify notebook development
C. To improve deployment speed
D. To reduce security risk and administrative exposure
Answer: D
Explanation
Admin roles have extensive privileges and should be assigned only when necessary.
Question 9
A company wants automated deployment processes that are not dependent on employee accounts.
What should be used?
A. Viewer accounts
B. Personal accounts
C. Service principals
D. Shared passwords
Answer: C
Explanation
Service principals provide stable, secure identities for automation and deployment activities.
Question 10
What is the primary benefit of separating Development, Test, and Production workspaces?
A. Increased storage capacity
B. Improved security and change control
C. Reduced OneLake storage usage
D. Faster notebook execution
Answer: B
Explanation
Environment separation helps prevent accidental production changes and supports proper testing and governance.
Exam Tip
For the DP-700 exam, many security questions can be solved by understanding the differences between the four workspace roles:
Role
Key Capability
Admin
Full control and permissions management
Member
Create, manage, and collaborate on content
Contributor
Create and modify content
Viewer
Read-only access
When evaluating scenarios, choose the lowest role that satisfies the requirement. Microsoft frequently tests the Principle of Least Privilege, making it one of the most important security concepts to master for the exam.