FREE DP-700 Exam Guide 2026: Pass Microsoft Fabric Data Engineer (Lakehouse, KQL, Pipelines)

DP-700 Exam Guide 2026: The Only Walkthrough Built Around the Current Skills Measured Outline

If you are a data engineer in 2026, the single biggest platform shift in your career is happening right now: Microsoft is consolidating Synapse Analytics, Azure Data Factory, and Power BI into one unified SaaS platform called Microsoft Fabric. The old certification ladder - DP-203 (Azure Data Engineer Associate) - was retired on March 31, 2025. Its successor, Exam DP-700: Implementing Data Engineering Solutions Using Microsoft Fabric, is now the sole Microsoft-branded credential for data engineers.

Most blog posts you will find still reference Synapse dedicated pools, Data Factory integration runtimes, and DP-203 domain weights. None of that is on DP-700. This guide is written exclusively for the 2026 exam window: current skills measured weights, the OneLake/Lakehouse/Warehouse/Eventhouse architecture, PySpark + T-SQL + KQL coverage, and the $165 scheduling fee at Pearson VUE. If you studied DP-203 before, read the migration section first - the mental model is different.

DP-700 Exam At-a-Glance (2026)

Source: Microsoft Learn exam page (learn.microsoft.com/credentials/certifications/exams/dp-700), Microsoft DP-700 Study Guide (PDF), and Pearson VUE scheduling portal.

---

Start Your FREE DP-700 Prep Today

Start FREE DP-700 practice questions for the Fabric Data Engineer Associate examPractice questions with detailed explanations

---

Why Fabric (and Why DP-700 Replaced DP-203)

Microsoft Fabric reached General Availability on November 15, 2023 and within 18 months consumed the roles previously held by five separate Azure services:

This is why DP-203 had to be retired. The legacy exam still tested Synapse dedicated pools, Polybase, and Data Factory integration runtime tuning - concepts that do not exist in Fabric's SaaS model. Microsoft formally retired DP-203 on March 31, 2025, giving existing holders a grace period to sit DP-700 before their Azure Data Engineer Associate expired.

DP-700 reached General Availability on January 17, 2025, following a beta period (exam ID DP-700-BETA) that opened on October 22, 2024 and closed on November 12, 2024. As of 2026 there is no beta discount left; everyone pays the full $165.

Who Should Sit DP-700

The Microsoft skills outline targets professionals who:

• Ingest and transform data using Lakehouse, Warehouse, or Eventhouse.
• Implement medallion architectures (Bronze -> Silver -> Gold) in OneLake.
• Write PySpark, T-SQL, and KQL comfortably (all three are in scope).
• Manage Fabric workspaces, capacity, deployment pipelines, and version control with Git.
• Monitor and optimize pipelines, Dataflow Gen2, notebooks, eventstreams, and semantic models.

If you only want one certification and your role is mostly dimensional modeling and Power BI, sit DP-600 (Fabric Analytics Engineer) first - but most modern Microsoft data teams now expect both.

---

Build DP-700 Mastery with FREE Practice Questions

Access FREE DP-700 practice questionsPractice questions with detailed explanations

---

DP-700 Skills Measured (2026 Domain Weights)

The official Microsoft Learn skills outline revised April 20, 2026 (the current version as of publication) breaks DP-700 into three major domains. The April 2026 revision introduced minor updates across security/governance (folder/file-level access, OneLake security, sensitivity labels, audit logs, endorsements) and streaming (Spark structured streaming, Real-Time Intelligence native tables vs OneLake shortcuts, query acceleration for shortcuts). If Microsoft revises the outline, new content is held for 30 days before appearing on the live exam.

Source: Microsoft DP-700 Study Guide, April 20, 2026 revision.

Unlike DP-203 (which had five domains weighted 10-40%), DP-700 is roughly evenly split across three domains. That means there is no single domain you can ignore - every one carries enough weight to sink a borderline score.

Domain 1: Implement and Manage an Analytics Solution (30-35%)

This domain is the single biggest surprise for DP-203 alumni because it is heavily ops-focused, not code-focused. Microsoft tests you on the SaaS governance primitives that make Fabric different from Synapse.

Configure Microsoft Fabric workspaces and items

• Configure workspace settings, roles, and licensing mode (Pro vs Premium Per User vs Fabric Capacity).
• Configure Fabric capacities (F2 through F2048) and capacity auto-scale.
• Understand Capacity Units (CUs) and smoothing - the heart of Fabric cost/performance management.
• Recommend domain structure for federated governance (Fabric domains, subdomains, and admin roles).

Implement lifecycle management

• Use deployment pipelines to move items from Dev -> Test -> Prod workspaces with parameter rules.
• Integrate workspaces with Git (Azure DevOps or GitHub) for version control.
• Implement database projects (SQL database project + Warehouse project) for schema-as-code workflows.
• Know supported items (Lakehouse, Warehouse, Notebook, Pipeline, Semantic model, Report, KQL database are Git-integrated as of 2026).

Configure security and governance

• Workspace roles: Admin, Member, Contributor, Viewer.
• Item-level permissions (share, build, read, reshare).
• Row-level security (RLS), column-level security (CLS), object-level security (OLS), folder/file-level access controls (OneLake security, GA 2025-2026), and dynamic data masking across Lakehouse SQL endpoints, Warehouses, and semantic models.
• OneLake data access roles and OneLake security (posix-style folder/file permissions added in the April 2026 skills outline).
• Apply sensitivity labels to items and inherit from source data (Microsoft Purview integration).
• Endorse items (Promoted, Certified) for trusted content surfacing.
• Implement and review Microsoft Fabric audit logs for governance and compliance.

Orchestrate processes

• Fabric Data Pipelines (successor to Azure Data Factory pipelines) for orchestration and scheduling.
• Notebook orchestration (triggers, chained notebooks, runMultiple).
• Reflex/Activator for event-driven automation.

Domain 2: Ingest and Transform Data (30-35%)

The heart of the exam - expect the largest number of scenario-based questions here.

Design and implement loading patterns

• Full load vs incremental load using watermarks, CDC, and delta detection.
• Medallion architecture: Bronze (raw), Silver (cleansed/conformed), Gold (aggregated/dimensional) in OneLake.
• Slowly Changing Dimensions (SCD) Type 1, 2, 6 implementation in Spark/T-SQL.
• Partitioning and Z-ordering Delta tables.

Ingest batch data

• Copy activity in Data Pipelines (400+ connectors).
• Dataflow Gen2 (Power Query M) for low-code transformations with staging.
• Shortcuts (OneLake, ADLS Gen2, Amazon S3, Google Cloud Storage, Dataverse) to virtualize data without copying.
• Database mirroring (Azure SQL DB, Cosmos DB, Snowflake, Azure Databricks Unity Catalog, Fabric SQL database) - near real-time replication into OneLake as Delta tables.

Ingest streaming data

• Eventstream for ingesting from Azure Event Hubs, Kafka, CDC streams, sample data, custom apps.
• Destinations: Lakehouse, Eventhouse (KQL DB), Activator, Custom Endpoint.
• Eventhouse + KQL Database for time-series/telemetry data.
• Spark structured streaming in notebooks for stateful, code-first streaming pipelines (added emphasis in the April 2026 outline).
• Real-Time Intelligence choices: native tables vs OneLake shortcuts, and query acceleration for OneLake shortcuts vs standard shortcuts (both testable trade-offs).
• Windowing functions (tumbling, hopping, sliding, session) for stream aggregation.

Transform data

• PySpark notebooks (Delta Lake APIs, sparkDataFrame, Spark SQL).
• T-SQL for Warehouse and SQL analytics endpoint (CTAS, COPY INTO, stored procedures).
• KQL (Kusto Query Language) for Eventhouse (summarize, join, ingestion-time policies, update policies).
• Dataflow Gen2 for Power Query M transformations with managed staging.

Domain 3: Monitor and Optimize an Analytics Solution (30-35%)

Often underestimated. The monitor/optimize domain is where candidates who skipped hands-on labs fail.

Monitor the solution

• Microsoft Fabric Capacity Metrics app (read CU usage, throttling, smoothing, background vs interactive operations).
• Monitor hub for pipeline, notebook, Dataflow Gen2, and eventstream runs.
• Alert rules and Activator reflexes.
• Log-based monitoring (workspace diagnostic settings to Log Analytics/Event Hub, Purview audit).

Identify and resolve errors

• Pipeline failures (retry policies, fault tolerance, skip rows).
• Notebook failures (OOM, job cancelled, driver errors in Spark).
• Dataflow Gen2 refresh failures and query folding issues.
• KQL ingestion errors (show ingestion failures, update policy failures).

Optimize performance

• Delta Lake optimization: OPTIMIZE, VACUUM, V-Order (Fabric's default write-time encoding that improves Power BI Direct Lake read speed).
• Spark tuning: partition pruning, broadcast joins, AQE (Adaptive Query Execution), autotune, native execution engine.
• T-SQL / Warehouse: result-set caching, statistics, distribution-aware queries, COPY INTO vs INSERT patterns.
• KQL: materialized views, ingestion batching, partitioning policies, caching policies.

---

Fabric Components You MUST Know Cold

Shortcuts and mirroring are two of the highest-yield concepts on the 2026 exam. A shortcut is a pointer - no data is copied. Mirroring is near real-time replication from an external source into OneLake as Delta tables. Both eliminate ETL for many scenarios; the exam tests when each is appropriate.

DP-700 vs DP-203: Migration Cheat Sheet

If you last studied for DP-203, here is what changed - study these deltas first.

The biggest mental-model flip: in Synapse you provisioned compute for each workload (SQL pool, Spark pool, IR). In Fabric you buy one capacity (in CUs) and every workload shares it, smoothed over 24 hours. That is why the monitor/optimize domain devotes real estate to CU accounting and throttling.

Languages on the Exam: PySpark, T-SQL, and KQL

DP-700 is one of the only Associate-level Microsoft exams that expects working fluency across three query languages. You will see code-read and code-write scenarios in all three.

PySpark / Spark SQL (Lakehouse + Notebook)

# Read a shortcut Delta table, partition by date, write with V-Order
df = spark.read.format("delta").load("Files/bronze/orders")
df = df.filter("order_date >= '2026-01-01'")
(df.write.format("delta")
    .option("parquet.vorder.enabled", "true")
    .partitionBy("order_date")
    .mode("overwrite")
    .saveAsTable("silver.orders"))

T-SQL (Warehouse + SQL analytics endpoint)

-- CTAS: create silver.orders from bronze with a watermark
CREATE TABLE silver.orders AS
SELECT order_id, customer_id, order_date, total_amount
FROM bronze.orders
WHERE last_modified > (SELECT COALESCE(MAX(last_modified), '1900-01-01') FROM silver.orders);

KQL (Eventhouse / KQL Database)

// Top 10 error codes in the last hour, with summarize + render
Telemetry
| where Timestamp > ago(1h) and Level == "Error"
| summarize Count = count() by ErrorCode
| top 10 by Count desc
| render columnchart

You do not need Spark Scala, R, or advanced DAX for DP-700. DAX appears lightly in the context of semantic models and Direct Lake performance, not as a first-class language.

8-Week DP-700 Study Plan (Built for Working Engineers)

Most candidates come from DP-203, DP-600, or hands-on Synapse/ADF work. This plan assumes ~8-10 hours per week and existing familiarity with Azure.

Time Allocation (Match the Blueprint)

Recommended DP-700 Resources (FREE-First)

Hands-On Labs Are Non-Negotiable

DP-700 is not a memorize-the-facts exam. Microsoft has moved aggressively toward performance-based / lab-style items. Case studies embed 2-4 pages of environment description and multiple linked questions. Without hands-on Fabric time you will run out of the exam's 100 minutes.

Use the free 60-day Fabric trial capacity (F64 equivalent) or your employer's Fabric tenant to build:

1. A Bronze -> Silver -> Gold medallion Lakehouse from a public dataset (NYC Taxi, Contoso).
2. A Dataflow Gen2 + Pipeline orchestration for daily refresh with parameters.
3. A Warehouse that reads from Lakehouse via SQL analytics endpoint and exposes a Gold semantic model in Direct Lake mode.
4. An Eventstream from sample Bicycle telemetry into Eventhouse + an Activator alert.
5. A workspace wired to Git (Azure DevOps), with a deployment pipeline Dev -> Test -> Prod and parameter rules.
6. An RLS / OLS / CLS configuration across Lakehouse SQL endpoint, Warehouse, and semantic model.

If you have built all six, you will recognize every scenario on the exam.

Common Pitfalls That Sink First-Time Scores

1. Studying Synapse/ADF concepts that do not exist in Fabric. Distribution choices (HASH, ROUND_ROBIN), integration runtimes, dedicated SQL pool sizing - none of this is on DP-700. If a resource spends two hours on it, the resource is out of date.
2. Underestimating KQL. DP-203 alumni who skipped KQL will see a material chunk of Domain 2 and Domain 3 they cannot answer. Do Kusto Detective Agency end-to-end.
3. Not understanding Capacity Units and smoothing. "Why is my pipeline throttled at 11pm when the capacity metrics show 40% usage?" is a real exam scenario. Smoothing and bursting need study.
4. Confusing shortcuts with mirroring. Shortcuts = pointer, zero copy, live data. Mirroring = near real-time replica as Delta in OneLake. The exam rewards picking the cheaper, lower-latency option for each scenario.
5. Skipping V-Order. V-Order is Fabric's default write-time encoding that makes Direct Lake reads fast. Knowing when to disable it (write-heavy staging tables) is testable.
6. Weak on Git + deployment pipelines. Domain 1 is 30-35% and leans heavily on lifecycle management. Practice wiring a workspace to Azure DevOps and deploying through three stages with parameter rules.
7. Ignoring Dataflow Gen2 staging. The staging toggle is a performance-critical setting that changes query folding behavior - this shows up in case studies.
8. No timed full-length practice. 100 minutes for 40-60 questions, including case studies, is tight. Two timed mocks minimum before test day.

Test-Day Logistics and Strategies

Before you sit:

• Confirm your Microsoft Learn Profile matches your government ID exactly.
• If online-proctored, run the Pearson VUE system check (OnVUE) 24 hours in advance; a single camera/mic glitch can cost you the slot.
• Clear your desk. Pearson VUE proctors will ask for a 360 degree room scan.

During the exam:

• You cannot go back to previous sections once submitted, but you can flag and review items within a section. Flag anything you are not >90% sure on.
• Case studies appear as standalone sections with 2-4 pages of business + technical context. Read the question first, then skim the case for the specific detail; do not read the entire case study twice.
• When two answers look defensible, pick the SaaS-native, lower-TCO option - Microsoft's exam philosophy rewards managed Fabric primitives over hand-rolled code.
• You have ~2 minutes per standalone item and ~4-5 minutes per case-study item. Pace accordingly.

After the exam:

• You receive a pass/fail result and scaled score (0-1000, pass = 700) immediately.
• A skills-measured breakdown is emailed within 1-3 business days.
• If you fail, you must wait 24 hours for the first retake, then 14 days for attempts 2-5 within a 12-month window.

Career Impact and Salary (Microsoft Fabric Data Engineer, 2026)

Microsoft Fabric adoption is growing faster than any Microsoft data platform launch in the past decade. Microsoft reported in Q2 FY26 (quarter ended December 31, 2025) that Fabric paid customers exceeded 31,000 with an annual revenue run rate of over $2 billion and 60% year-over-year revenue growth - making Fabric the fastest-growing analytics platform on the market. That demand has spilled directly into the labor market.

Fabric-Adjacent Career Ladder

Deep Dives on Five Topics Competitor Guides Skim

1. Capacity Units, Smoothing, and Throttling

Fabric is billed by Capacity Units (CUs). An F2 provides 2 CU-seconds per second; an F64 provides 64 CU-seconds per second. Every Fabric operation (Spark job, pipeline activity, KQL query, Power BI query, Dataflow refresh) consumes CU-seconds. Two classifications determine billing and throttling behavior:

• Interactive operations (Power BI queries, KQL interactive queries, SQL analytics endpoint queries) are smoothed over 5 minutes. If usage exceeds capacity for longer than a few minutes, interactive queries are delayed or rejected.
• Background operations (Data Pipeline runs, Notebook jobs, Dataflow Gen2 refresh, Warehouse load, KQL ingestion) are smoothed over 24 hours. Background overage can be borrowed from future capacity (bursting) up to a cap, then the capacity is throttled.

When throttling kicks in, Fabric progresses through states: overage (within 10 min of future capacity) -> throttling of interactive delay (20 sec delay added) -> throttling of interactive reject -> throttling of background reject. On the exam, expect scenario items where the fix is "scale to a higher SKU" vs "spread workloads across time" vs "offload to another capacity."

2. Direct Lake Mode and V-Order

Power BI Direct Lake mode reads Delta parquet files in OneLake directly into the in-memory VertiPaq engine at query time, with no scheduled import. It requires V-Order for optimal performance. Fallbacks to DirectQuery happen when: a table exceeds SKU row limits, TM1 transformations are unsupported, or calculated columns reference patterns that require on-demand compute. Knowing the fallback triggers is a recurring DP-700 case-study pattern.

3. OneLake Security Model

Fabric's security model is layered and non-obvious:

• Workspace roles (Admin, Member, Contributor, Viewer) grant coarse permissions across a workspace.
• Item permissions (share, build, read, reshare) grant fine-grained access to specific Lakehouses, Warehouses, or semantic models.
• OneLake data access roles (preview/GA 2025-2026) grant POSIX-like access to folders inside a Lakehouse for Spark users.
• SQL-level security (RLS, CLS, OLS, dynamic data masking) applies at the Warehouse and SQL analytics endpoint level.
• Purview sensitivity labels flow through Fabric items and can be inherited from source data.

Case-study items frequently present a scenario where a user has workspace Member access but still cannot read a specific table - the answer is almost always a missing item permission or a conflicting OneLake data access role.

4. Dataflow Gen2 Staging and Query Folding

Dataflow Gen2 has a staging toggle per query. When staging is ON, Fabric writes intermediate results to a hidden Lakehouse, then subsequent transformations read from that staging layer. This enables folding of downstream steps that could not fold against the original source (e.g., combining a SharePoint list with a SQL table). Staging increases storage CU consumption but often cuts total refresh time dramatically. Exam items reward knowing when to stage (heterogeneous sources, complex joins) vs disable staging (single-source passthrough with full folding).

5. KQL Performance Patterns

Three KQL patterns show up frequently on DP-700:

• Materialized views pre-aggregate expensive queries and auto-update as new data arrives. Best for high-cardinality aggregations queried frequently.
• Update policies run a KQL transformation on ingestion, writing results to a target table. Best for schema-on-write scenarios and light cleansing.
• Partitioning and caching policies control hot-cache retention and data distribution. A 30-day hot cache with 2-year cold retention is a common pattern for operational dashboards over long-retention telemetry.

Know the difference between an update policy (executed at ingestion time, writes to another table) and a materialized view (executed at query time over already-ingested data).

How DP-700 Fits into the Broader Microsoft Data Certification Path

Fabric-connected roles increasingly expect DP-700 + DP-600 as the baseline pair.

Renewal and Continuing Competency

Like all Microsoft role-based certifications, the Fabric Data Engineer Associate is valid for one year. Renewal is FREE via Microsoft Learn - a browser-based assessment opens 6 months before expiration. It is typically 25-35 questions covering what has changed in the product (new Fabric items, API changes, governance features) since your initial pass. There is no proctoring and you can retake renewals unlimited times.

Renewal is the closest thing Microsoft has to continuing education in data engineering. Do not let it lapse - an expired credential cannot be renewed and you would need to re-sit the full DP-700 at $165.

Total Cost of DP-700 Certification (2026)

DP-700 vs DP-600: Which First?

Both are Fabric Associate exams. If you must pick one:

A clean rule: if you have written more Spark than DAX, take DP-700. If you have written more DAX than Spark, take DP-600.

---

Keep Training with FREE DP-700 Practice

Practice DP-700 scenario questionsPractice questions with detailed explanations

---

Frequently Missed 2026 Details (Competitor Guides Get These Wrong)

• DP-203 is gone. If a guide tells you to study DP-203 first "for fundamentals," it is out of date. Skip to DP-700 + DP-900 (if you are new).
• V-Order is on by default for new Lakehouse tables. Disabling it for staging layers is testable.
• Fabric capacity uses smoothing over 24 hours, not real-time metering. This is why throttling appears asymmetrically relative to real-time CU usage.
• Direct Lake mode does not import data - the semantic model reads Delta files in OneLake directly. Exam items hinge on knowing when Direct Lake falls back to DirectQuery.
• Mirroring is free on compute side for most sources but uses OneLake storage; not all connectors support mirroring (check the current list).
• Domains and subdomains (Fabric governance construct) are not the same as DNS domains - this trips up candidates when a question mixes the two.
• KQL update policies and materialized views are highly testable optimization tools in Eventhouse.
• Deployment pipeline parameter rules are the supported way to swap connection strings across Dev/Test/Prod; branch-based deployment alone is not the answer Microsoft wants.
• April 20, 2026 outline additions you should know cold: folder/file-level access controls in OneLake security, item endorsements (Promoted, Certified), Spark structured streaming, Real-Time Intelligence native tables vs OneLake shortcuts, and query acceleration for OneLake shortcuts.
• Database projects (SQL database + Warehouse projects for schema-as-code) are now explicit in lifecycle management - know how they differ from deployment pipelines and Git integration.

Official Sources Used

• Microsoft Learn - Exam DP-700: Implementing Data Engineering Solutions Using Microsoft Fabric (skills outline, April 20, 2026 revision)
• Microsoft Learn - DP-700 Study Guide (aka.ms/DP700-StudyGuide, updated April 2026)
• Microsoft Certified: Fabric Data Engineer Associate credential page
• Microsoft Fabric documentation (learn.microsoft.com/fabric)
• Pearson VUE Microsoft exam scheduling portal (fee and retake policy)
• Microsoft Learn credential renewal policy (6-month renewal window, free online assessment)
• Microsoft FY26 Q2 earnings - Fabric customer metrics (31,000+ paid customers, 60% YoY growth)
• Glassdoor / Levels.fyi / Dice / Robert Half - 2026 salary references
• LinkedIn Talent Insights - Fabric job demand signals
• Kusto Detective Agency (Microsoft official KQL training)

Certification details, fees, and skills measured may be revised by Microsoft. Always confirm current requirements directly on learn.microsoft.com before scheduling.