← Certifications

DP-700activeintermediateCurrently studying

DP-700 Study Guide: How I’m Preparing for the Microsoft Fabric Data Engineer Exam

Exam DP-700: Implementing Data Engineering Solutions Using Microsoft Fabric

Fabric Data Engineer

My DP-700 study system mapped to the October 19, 2026 blueprint, with study cards that take each skill group from understanding to break/fix practice, a coverage matrix, an end-to-end project, troubleshooting drills and an exam readiness checklist.

Last verified against Microsoft Learn:

Core skill areas

  • Implement and manage an analytics solution (30–35%)
  • Ingest and transform data (30–35%)
  • Monitor and optimize an analytics solution (30–35%)

Practical experience recommended

  • Data loading patterns, data architectures and orchestration processes
  • Manipulating and transforming data with SQL, PySpark and KQL
  • Securing, monitoring, troubleshooting and optimizing Fabric workloads
On this page

I’m preparing for DP-700 myself. I built this study path around three things: the current Microsoft skills measured, the Fabric work I already do in practice, and the areas I need to study and test on purpose. It is the plan I’m following, written down so I can track it and so you can reuse it.

It answers one question: what do I need to learn, practice and be able to do before I take DP-700?

Exam at a glance

Item Detail
Certification Microsoft Certified: Fabric Data Engineer Associate
Exam DP-700: Implementing Data Engineering Solutions Using Microsoft Fabric
Role and level Data Engineer · Intermediate
Blueprint update October 19, 2026 (shown as “Last Updated” on the certification page)
Duration 100 minutes, proctored; the exam may include interactive components
Passing score 700 or greater (exam scoring)
Languages English, Japanese, Chinese (Simplified), Chinese (Traditional), German, French, Italian, Korean, Spanish, Portuguese (Brazil). Localized versions follow English updates by about eight weeks.
Languages you must use SQL, PySpark and KQL
Official study guide DP-700 study guide
Practice assessment New Practice Assessment on AI Skills Navigator (sign-in required). The legacy Learn assessment is no longer updated.
Exam sandbox Try the exam interface
Retakes and renewal Retake policy · Free annual renewal

Microsoft notes that most questions cover generally available features, but commonly used Preview features may appear. The bullets under each skill illustrate what is assessed; related topics can also come up.

How to use this guide

The guide answers one practical question for each part of the exam: what should I understand, what should I be able to do, what should I deliberately break and fix, and what decisions should I be able to explain?

  1. Take a baseline. Do the Practice Assessment before studying, without looking anything up. Note weak domains, not questions.
  2. Review the three domains in Skills measured and the coverage matrix, so you know where this guide helps and where it doesn’t yet.
  3. Work through the study cards. For each skill group: understand the concepts, do the task, break and fix something related, and explain the decision.
  4. Score the readiness checklist only after hands-on practice. Before that, you’re rating familiarity, not ability.
  5. Build the end-to-end project. It joins the card tasks into one platform instead of separate demos.
  6. Revisit weak domains with the objective exercises and troubleshooting drills.
  7. Retake the practice assessment after a gap of at least a week, then decide whether to book.
  1. 1UnderstandConcepts from Microsoft Learn
  2. 2DoBuild it without a tutorial
  3. 3Break / FixCause a failure, then diagnose it
  4. 4ExplainJustify the decision and tradeoff
  5. 5Assess readinessEvidence, checklist, practice assessment
The study loop. Every study card follows the same five steps. A low readiness score sends you back to Do and Break / Fix, not to rereading.

Microsoft Learn and this guide

Source What it is for
Microsoft Learn Authoritative platform documentation, the official exam objectives, learning paths, the practice assessment and exam logistics.
Javi Builds Study order, hands-on practice, troubleshooting, decision-making, evidence and readiness.

This guide links to Learn rather than restating it. Where the two disagree, Microsoft Learn is right.

Skills measured

The October 19, 2026 blueprint has three equally weighted domains: 10 skill groups and 49 objectives. The objective wording in this guide is Microsoft’s; check the live study guide before you schedule.

  • Implement and manage30–35% · 16 objectives
    1. Workspace settingsSpark, domain, OneLake, data workflow
    2. Lifecycle managementVersion control, database projects, deployment pipelines
    3. Security and governanceAccess controls, masking, labels, endorsement
    4. OrchestrationPipelines, notebooks, triggers, parameters
  • Ingest and transform30–35% · 17 objectives
    1. Loading patternsFull, incremental, dimensional, streaming
    2. Batch dataStores, shortcuts, mirroring, PySpark, SQL, KQL
    3. Streaming dataEventstreams, structured streaming, KQL, windows
  • Monitor and optimize30–35% · 16 objectives
    1. Monitor Fabric itemsIngestion, transformation, refresh, alerts
    2. Identify and resolve errorsPipeline, dataflow, notebook, eventhouse, eventstream, T‑SQL
    3. Optimize performanceLakehouse, pipeline, warehouse, RTI, Spark, queries
The DP-700 blueprint. Three domains, each 30–35% of the exam. Read each column top to bottom; the order is the order I study the skill groups, not a dependency.

Two wording details matter. “Data workflow” is the earlier name of Fabric’s Apache Airflow job. The orchestration objective asks you to choose between a pipeline and a notebook; the choice between dataflows, notebooks and T-SQL appears under batch transformation.

Coverage matrix

Each official DP-700 objective is mapped to the most relevant Javi Builds material and a practical next step. Where Javi Builds doesn’t cover an objective yet, it says Not covered yet, and the Practice column gives you a hands-on exercise with a Learn link to the Microsoft Learn page to study first.

Reading is only half of it. Use the links to understand the objective, then do the Practice task in a test workspace: it’s the part that shows whether you can actually do it. Labs marked docs-based are guided exercises written from current Microsoft Learn documentation; I haven’t yet run them end to end in my own tenant, so compare what you see with the linked documentation.

Domain 1: Implement and manage an analytics solution

Exam objective Javi Builds resource Practice
Configure Spark workspace settings Workspace settings cheat sheet, high concurrency session limit, notebook startup time, runtime comparison Configure pools, environment and job limits; check them in a session
Configure domain workspace settings Workspace settings cheat sheet, governance: domains Assign a workspace to a domain; find it in the OneLake catalog
Configure OneLake workspace settings Workspace settings cheat sheet Turn on the shortcut cache and OneLake diagnostics
Configure data workflow workspace settings Workspace settings cheat sheet Run an Apache Airflow job on the starter pool and on a custom pool
Configure version control Connect Fabric to Git, Git integration workflow, lifecycle lab (docs-based) Commit from Fabric, update from Git, resolve one conflict
Implement database projects Lifecycle lab: Warehouse as a database project (docs-based) Build a database project and deploy a schema change
Create and configure deployment pipelines Lifecycle lab (docs-based), fabric-cicd, CI/CD deployment checklist Promote Dev to Test with a deployment rule
Implement workspace-level access controls Security architecture: workspace roles, security lab exercise 1 (docs-based) Test Viewer vs Contributor
Implement item-level access controls Security architecture: item permissions, security lab exercises 2 and 7 (docs-based) Share an item; compare Read, ReadData and ReadAll
Implement row-level, column-level, object-level, and file-level access controls Security architecture: data-level security, security lab exercises 3–5 (docs-based) Implement each control and test it as a second user
Implement dynamic data masking Security lab exercise 6 (docs-based) Mask a column; query as two users
Apply sensitivity labels to items Governance: sensitivity labels Label an item; check inheritance
Endorse items Governance: data product trust model Promote one item, certify another
Choose between a pipeline and a notebook Pipelines vs Notebooks vs Dataflow Gen2 vs Copy job Justify the tool for three real tasks
Design and implement schedules and event-based triggers Not covered yet Schedule a pipeline and trigger it on file arrival (Learn)
Implement orchestration patterns with notebooks and pipelines, including parameters and dynamic expressions Notebook parameters, Invoke Pipeline activity, session tags Build and rerun a parameterized pipeline

Domain 2: Ingest and transform data

Exam objective Javi Builds resource Practice
Design and implement full and incremental data loads Incremental loads, incremental load patterns, testing incremental loads Build a watermark load and rerun it safely
Prepare data for loading into a dimensional model Bronze, Silver, Gold in Fabric, design patterns, Lab 01 Gold Build a dimension with surrogate keys and SCD type 2
Design and implement a loading pattern for streaming data ETL vs ELT vs CDC vs streaming, batch vs streaming, Real-Time Intelligence guide (docs-based) Land telemetry in an Eventhouse through an eventstream
Choose an appropriate data store Lakehouse vs Warehouse, decision guide, the Eventhouse’s role (docs-based) Pick a store for five workloads and justify it
Choose between dataflows, notebooks, and T-SQL for data transformation Pipelines vs Notebooks vs Dataflow Gen2, Lakehouse vs Warehouse Build one transformation three ways
Create and manage shortcuts to data Shortcuts section, zero-copy patterns Create a shortcut, then break its access
Implement mirroring Mirror Azure SQL into Fabric Mirror a table; check replication status
Ingest data by using pipelines Copy job vs Copy activity, Lab 01 orchestration Load a file with a parameterized Copy activity
Transform data by using PySpark, SQL, and KQL PySpark exploration, notebook tutorial, first Warehouse with T-SQL, KQL cheat sheet Write one transformation in PySpark, T-SQL and KQL
Denormalize data Lab 01 Gold layer, medallion visual guide Flatten orders and lines; check row counts
Group and aggregate data PySpark aggregations, GROUP BY, KQL summarize Aggregate with groupBy, GROUP BY and KQL summarize
Handle duplicate, missing, and late-arriving data Incremental loads, testing duplicates and late data, duplicate rows after JOIN, NULL, Lab 01 data quality Deduplicate, handle nulls and MERGE a late row
Choose an appropriate streaming engine Choose a streaming engine (docs-based) Decide where the work belongs for one source: eventstream, Eventhouse or Spark
Process data by using eventstreams Real-Time Intelligence guide, steps 1–4 (docs-based) Route custom-endpoint events into an Eventhouse
Process data by using Spark structured streaming Structured Streaming in brief (docs-based) Stream files into Delta with a checkpoint, then restart it (Learn)
Process data by using KQL KQL cheat sheet, Real-Time Intelligence guide, steps 5–10 (docs-based) Do the seven cheat-sheet exercises without notes
Create windowing functions Windowing, three ways (docs-based), KQL time windows Build the same 1-minute window in the eventstream and in KQL

Domain 3: Monitor and optimize an analytics solution

Exam objective Javi Builds resource Practice
Monitor data ingestion Monitoring pipelines and notebooks, monitoring cheat sheet Read a run’s history in the Monitoring hub
Monitor data transformation Execution log design, monitoring checklist Compare a run’s row counts with a baseline
Monitor semantic model refresh Not covered yet Fail a refresh; read its history (Learn)
Configure alerts Monitoring: alerts Create an Activator alert and trigger it
Identify and resolve pipeline errors Debugging pipelines and notebooks, debug pipelines, controlled failure tests Break a Copy activity; fix it from the error
Identify and resolve dataflow errors Not covered yet Break a step; trace it (Learn)
Identify and resolve notebook errors Debugging pipelines and notebooks Cause a schema mismatch; fix it
Identify and resolve eventhouse errors Not covered yet Find a failed ingestion (Learn path)
Identify and resolve eventstream errors Not covered yet Send malformed events; find the error (Learn)
Identify and resolve T-SQL errors Safe UPDATE and DELETE, find blocking (SQL Server engine) Fix a permission, conversion and blocking error
Optimize a lakehouse table Delta maintenance, partitioning checklist Measure a query before and after OPTIMIZE
Optimize a pipeline Invoke Pipeline activity, session tags, performance troubleshooting Compare sequential and parallel ForEach
Optimize a data warehouse Not covered yet Tune one slow query (Learn)
Optimize eventstreams and eventhouses Not covered yet Compare a query with and without a time filter (Learn)
Optimize Spark performance Make notebooks faster, notebook performance checklist, PySpark performance, capacity Diagnose and fix a slow Spark job
Optimize query performance SQL Server tuning checklist, Delta MERGE performance Speed up one slow query per engine

Where I’m still building study material

This is where I’m still building study material. The coverage audit, not a guess, decides this list, and it will change as I study and publish.

Well covered. Incremental loads and watermarks, pipeline vs notebook decisions, parameterized orchestration, Git version control, workspace roles, mirroring, Delta table maintenance, Spark and notebook performance, pipeline and notebook troubleshooting, and monitoring ingestion and transformation. For these I revise, then prove it with a timed exercise without notes.

Need practice. Covered by a reference or a guided exercise, but not yet practised end to end: deployment pipelines with rules, Warehouse database projects, item permissions, row-, column-, object- and folder-level security and dynamic data masking (guided by the docs-based Fabric Security Lab and lifecycle lab, both waiting for tenant validation), the Spark, domain, OneLake and data workflow workspace settings (see the workspace settings cheat sheet), KQL (see the KQL cheat sheet), eventstreams, streaming-engine choice, windowing and Spark structured streaming (guided by the docs-based Real-Time Intelligence guide), sensitivity labels and endorsement, shortcuts, Copy activity ingestion, dimensional-model preparation, the dataflow vs notebook vs T-SQL choice, alerts, pipeline optimization and Fabric Warehouse T-SQL errors.

Need focused study (known gaps). New ground, studied from Microsoft Learn first: Real-Time Intelligence operations (eventhouse and eventstream errors, optimizing eventstreams and eventhouses), Fabric Warehouse optimization, Dataflow Gen2 errors, semantic model refresh monitoring, and schedules and event-based triggers.

Study roadmap

This eight-week plan assumes some Fabric experience and five to eight hours a week. It isn’t mandatory: the shorter and longer paths below reuse the same blocks.

Week Focus Objectives practised Evidence to produce
1 Blueprint and Fabric environment Workspace settings, security, version control, deployment Personal objective checklist, baseline practice assessment, gap list
2 Batch ingestion Pipelines and Copy, incremental loads, shortcuts, mirroring, Dataflow Gen2 Watermark load that reruns safely; a broken shortcut fixed
3 Lakehouse and PySpark Delta, transformations, duplicates and late data, Spark optimization and troubleshooting Silver and Gold tables; one slow job diagnosed and measured
4 Warehouse and SQL T-SQL ingestion and transformation, RLS/CLS/OLS, masking, query optimization Warehouse Gold layer with security tested as two users
5 Real-Time Intelligence Eventstream, Eventhouse, KQL, streaming engine choice, windowing Event path into an Eventhouse; five KQL queries written from memory
6 Operations Monitoring, alerts, refresh monitoring, error resolution across item types Three controlled failures diagnosed and written up
7 Build and test End-to-end solution, failures, optimization, security, deployment Repository, deployment run, before/after performance numbers
8 Final review Weak domains only Practice assessment retake, sandbox reviewed, readiness decision

Shorter path (about 4 weeks), if you already operate Fabric batch workloads: week 1 combines weeks 1 and 2 above, week 2 is Real-Time Intelligence, week 3 is Warehouse, security and operations, and week 4 is build, retake and decide.

Longer path (10–12 weeks), if Fabric or Spark is new to you: give weeks 3 and 5 two weeks each, and add a buffer week before the final review.

The general-purpose Fabric Certification Study Planner is the printable companion for this schedule: it has the weekly review loop and the evidence-based readiness decision. This page is the DP-700-specific layer on top of it.

Study cards by skill group

One card per official skill group: ten in total. Each card has the same four steps, then the resources and the matching readiness checks: study this, practise here, assess readiness there. Detailed material stays in its own cheat sheet, lab or article; the card only points to it. The tasks build on the end-to-end project; the objective exercises go one objective deeper. Known gap marks where I’m still building study material, so the card points to Microsoft Learn instead.

Do every Break / Fix task in a test workspace with test data.

Domain 1: Implement and manage an analytics solution

Workspace settings

  • Understand: Spark pools, environments and the default runtime; OneLake settings; domain assignment; data workflow (Apache Airflow job) settings.
  • Do: configure a test workspace with the five-step Next step in the workspace settings cheat sheet, and write down the settings that materially change how your solution runs.
  • Break / Fix: make an environment without a library your notebook imports the workspace default; read the error, then restore it. Then check from inside a session which runtime and executor settings it really got.
  • Explain: which settings are operational, which are security-related and which are workload-related, and why a domain is not an access control.
  • Resources: workspace settings cheat sheet, notebook startup time, runtime comparison. No guided lab yet: the cheat sheet’s verify steps are the practice. Readiness: Domain 1 checks.

Lifecycle management

  • Understand: what Git integration stores, deployment pipelines and deployment rules, SQL database projects, and separate Dev, Test and Prod workspaces.
  • Do: connect a workspace to Git, change a notebook and a Warehouse view as code, and deploy both to a Test workspace with a deployment pipeline.
  • Break / Fix: deploy a notebook whose default Lakehouse still points at Dev; find why Test behaves differently, then fix it with a deployment rule. Then make a database project deployment stop on possible data loss and decide what to do.
  • Explain: what Git protects (item definitions, history, review) and what it doesn’t (table data, workspace permissions, credentials), and what each of Git, deployment pipelines and database projects is not for.
  • Resources: lifecycle lab: Git, deployment pipelines and database projects (guided practice; docs-based, tenant validation pending), Connect Fabric to Git, fabric-cicd, CI/CD deployment checklist; Lab 06 (coming soon). Readiness: Domain 1 checks.

Security and governance

  • Understand: workspace roles, item permissions, row-, column- and object-level security, OneLake security roles, dynamic data masking, sensitivity labels and endorsement.
  • Do: create two test users and prove each one’s effective access through T-SQL and through Spark: workspace role, item share, row-, column- and object-level security, a OneLake folder role and a masked column.
  • Break / Fix: secure a table with row-level security in the Warehouse, then read the same table from a notebook as a workspace Contributor. Note what the rule didn’t stop. Then give a restricted reader ReadAll and find why the folder restriction stopped working.
  • Explain: why a workspace role alone may not enforce the full data-security model.
  • Resources: Fabric Security Lab (exercises 1–8; docs-based, tenant validation pending), Fabric security architecture, security review checklist, governance for sensitivity labels and endorsement. Readiness: Domain 1 checks.

Orchestration

  • Understand: pipeline vs notebook, schedules, event-based triggers, parameters and dynamic expressions.
  • Do: build a parameterized pipeline that passes a load date into a notebook.
  • Break / Fix: pass an invalid date, then make a downstream activity depend on the wrong outcome; diagnose each failure from the activity output.
  • Explain: when pipeline orchestration beats notebook-only orchestration (dependencies, retries, mixed activity types, run history) and when a notebook is enough.
  • Resources: Pipelines vs Notebooks, notebook parameters, Invoke Pipeline activity; Lab 02 (coming soon). Known gap: storage event triggers. Readiness: Domain 1 checks.

Domain 2: Ingest and transform data

Loading patterns

  • Understand: full vs incremental loads, watermarks, CDC, idempotency, late-arriving data and replay; surrogate keys and slowly changing dimensions; where streaming data lands.
  • Do: build an incremental load using a watermark, and a dimension with surrogate keys.
  • Break / Fix: rerun the same batch and verify that no duplicates are created; then replay from an older watermark and confirm the result is identical.
  • Explain: when you would choose CDC, or mirroring, instead of a watermark.
  • Resources: Incremental loads, incremental load patterns, Bronze, Silver, Gold; Labs 02 and 05 (coming soon). Readiness: Domain 2 checks.

Batch data

  • Understand: choosing Lakehouse, Warehouse or Eventhouse; shortcuts, mirroring and the Copy activity; Dataflow Gen2, notebooks and T-SQL; denormalizing and aggregating; duplicate, missing and late data.
  • Do: ingest one source with a Copy activity and another through a shortcut; then implement the same small transformation in SQL and in PySpark.
  • Break / Fix: change the source path or a column type and diagnose the failure; then add duplicate and late-arriving rows and fix the result.
  • Explain: shortcut vs Copy vs mirroring, and why you’d choose SQL, PySpark or Dataflow Gen2 for a specific workload.
  • Resources: Lakehouse vs Warehouse, Mirror Azure SQL into Fabric, Pipelines vs Notebooks vs Dataflow Gen2, PySpark exploration, Warehouse with T-SQL, KQL cheat sheet, Lab 01. Known gap: hands-on Dataflow Gen2 material. Readiness: Domain 2 checks.

Streaming data

  • Understand: Eventstream (capture, process and route events), Eventhouse (store and query them), KQL, Spark structured streaming, tumbling and hopping windows, and how to choose between Eventstream, KQL and Spark.
  • Do: build one simple real-time flow: custom-endpoint events through an eventstream into an Eventhouse table; then query it in KQL with summarize and bin(), and build the same 1-minute window in the eventstream.
  • Break / Fix: rename a field in the events so it no longer matches the table mapping, shift event timestamps so a time filter misses them, and hide a failure burst with too large a window; find the evidence for each before fixing it.
  • Explain: when Real-Time Intelligence is justified instead of batch: the latency the business actually needs, the event volume, and the cost of always-on processing.
  • Order that works: KQL basics on static data with the KQL cheat sheet, then the guide’s learning order for the live flow, then the Real-Time Intelligence learning path for depth.
  • Resources: KQL cheat sheet, Real-Time Intelligence guide (docs-based), batch vs streaming, ETL vs ELT vs CDC vs streaming. Readiness: Domain 2 checks.

Domain 3: Monitor and optimize an analytics solution

Monitoring

  • Understand: the Monitoring hub for pipelines and notebooks, semantic model refresh history, alerts, and your own execution logs.
  • Do: run the project pipeline and collect its evidence: duration, rows, activity history and the Spark application.
  • Break / Fix: cause a controlled failure and find the root cause from the evidence alone, before searching.
  • Explain: point-in-time monitoring (is it healthy now?) vs historical evidence (what changed, compared with which baseline?), and why you need both.
  • Resources: Monitoring pipelines and notebooks, monitoring cheat sheet, execution log design; Lab 04 (coming soon). Known gap: semantic model refresh. Readiness: Domain 3 checks.

Identify and resolve errors

  • Understand: where each engine reports errors: pipeline run output, Dataflow refresh history, Spark errors, Eventstream data insights, Eventhouse ingestion failures, T-SQL messages, and shortcut errors in the Lakehouse explorer.
  • Do: diagnose at least one failure in each major engine.
  • Break / Fix: use the controlled failures in Troubleshooting preparation, not theoretical examples.
  • Explain: which evidence source you would check first for each failure, and why.
  • Resources: Debugging pipelines and notebooks, debug pipelines. Known gap: Dataflow, Eventstream and Eventhouse errors; start with Dataflow Gen2 monitoring. Readiness: Domain 3 checks.

Optimize performance

  • Understand: Delta maintenance, Spark shuffles and skew, Warehouse statistics and data types, pipeline parallelism, Eventhouse policies, and capacity contention.
  • Do: measure a slow workload, make one change, and re-measure.
  • Break / Fix: create a deliberately inefficient pattern, such as many small files or a skewed join, and diagnose it from file counts and the Spark UI.
  • Explain: why one optimization helps and another doesn’t; for example, why OPTIMIZE fixes small files but not a skewed join.
  • Resources: Delta maintenance, Make notebooks faster, notebook performance checklist, performance troubleshooting. Known gap: Warehouse performance and Eventhouse optimization. Readiness: Domain 3 checks.

Common confusion points

These are the distinctions that change a design decision, and that scenario questions tend to turn on.

Pair The distinction that matters
Workspace role vs data security A workspace role opens every item, through every engine. Row-, column- and object-level rules and OneLake security narrow what Viewers and shared users read; Admins, Members and Contributors can still read the files directly.
Lakehouse vs Warehouse Both store Delta tables in OneLake. The Lakehouse is written with Spark and read through a read-only SQL endpoint; the Warehouse is written with T-SQL and supports multi-table transactions.
Shortcut vs copy A shortcut reads data in place: no copy, but it depends on the source’s availability and permissions. A copy is yours to control, and yours to store and refresh.
Mirroring vs ingestion Mirroring replicates a supported database into OneLake continuously, with nothing to schedule. Ingestion is a pipeline or notebook you build, schedule and transform within.
Pipeline vs notebook A pipeline orchestrates and moves data; a notebook runs transformation code. Most designs use a pipeline to run notebooks.
SQL vs PySpark Both can produce the same result. The store usually decides: T-SQL writes to a Warehouse, Spark writes to a Lakehouse. Then team skills and how complex the logic is.
Dataflow Gen2 vs notebook Dataflow Gen2 is low-code Power Query for simpler shaping; a notebook suits complex logic, large volumes and code you want to test and version.
Batch vs streaming The latency the business needs decides, not the technology. Streaming adds always-on cost and more to operate.
Eventstream vs Eventhouse Eventstream moves and processes events in flight; Eventhouse stores them and answers KQL queries. A typical flow uses both.
Git vs backup Git versions item definitions, not table data. Recovering data relies on Delta history, retention and a recovery design.
Monitoring vs optimization Monitoring shows what happened and whether it’s healthy; optimization changes the workload, and needs a monitoring baseline to prove it worked.

What not to memorize

The exam describes scenarios. A memorized menu path doesn’t help if you can’t tell which tool the scenario needs.

  • Don’t spend time on: the exact UI location of every button, practice questions and their answers, syntax you have never run, or product limits that no objective depends on.
  • Spend it on: what each capability does, how a workflow runs end to end, which option you’d choose and why, how you’d troubleshoot it, and the tradeoffs.

What you should be able to build before DP-700

One project ties the whole certification path together: build and operate a production-style Fabric data platform. It starts from Lab 01: End-to-End Sales Analytics, which already builds a workspace, a Lakehouse, Bronze/Silver/Gold notebooks and an orchestrating pipeline, and extends it step by step. Each study card’s Do and Break / Fix tasks happen inside this project.

  1. IngestFiles, Copy, shortcuts, mirroring, events
  2. TransformPySpark, T-SQL, KQL
  3. ServeGold Lakehouse and Warehouse
  4. SecureRoles, RLS/CLS, masking, labels
  5. MonitorRuns, refresh, alerts, failures
  6. OptimizeDelta, Spark, Warehouse, KQL
The study project, end to end. Six stages of one platform built on the Lab 01 dataset. Each stage exercises objectives from more than one exam domain.
# Step Where to build or learn it
1 Create the workspace Lab: Lab 01, step 1; cheat sheet: workspace settings
2 Configure source control Article: Connect Fabric to Git; hands-on: lifecycle lab, steps 1–2
3 Ingest batch data Lab: Lab 01, steps 3–4; add a parameterized Copy activity
4 Add incremental loading Article: Incremental loads; cheat sheet: incremental load patterns; planned Lab 02
5 Transform in PySpark Lab: Lab 01, steps 5–7; cheat sheet: PySpark aggregations
6 Transform in SQL Article: First Fabric Warehouse with T-SQL
7 Serve through Lakehouse and Warehouse Article: Lakehouse vs Warehouse; planned Lab 05
8 Secure access Hands-on: Fabric Security Lab; article: Fabric security architecture
9 Add orchestration Lab: Lab 01, step 8; article: notebook parameters; planned Lab 02
10 Add monitoring Article: Monitoring pipelines and notebooks; cheat sheet: monitoring; planned Lab 04
11 Cause and diagnose a failure Lab: Lab 01, step 6; cheat sheet: debug pipelines; planned Lab 03
12 Optimize a slow workload Checklist: notebook performance; article: Delta maintenance
13 Add a Real-Time Intelligence extension Hands-on: Real-Time Intelligence guide (docs-based); cheat sheet: KQL; Microsoft Learn: Real-Time Intelligence path
14 Deploy through lifecycle tooling Hands-on: lifecycle lab, steps 3–6; article: fabric-cicd; planned Lab 06
15 Validate the whole solution This page: evidence of readiness and the readiness checklist

Labs 02–06 follow the published labs roadmap and aren’t available yet. Until they are, each step has an article, cheat sheet, hands-on lab article or Microsoft Learn page above, and an exercise below that you can do on the Lab 01 workspace.

Objective-specific exercises

The study cards work at skill-group level; these exercises go one objective at a time, for the objectives where a card isn’t enough. Where possible, each one makes something fail on purpose: the exam rewards diagnosing a scenario, not remembering a menu.

Implement and manage an analytics solution

  • Spark workspace settings: create a custom pool and an environment, make it the workspace default, and measure notebook start time before and after.
  • Domain workspace settings: assign the workspace to a domain and check what the domain changes for discovery and delegated settings.
  • OneLake workspace settings: turn on the shortcut cache and OneLake diagnostics, then read the first diagnostic events from the lakehouse (cheat sheet).
  • Data workflow workspace settings: create an Apache Airflow job, compare the starter pool with a custom pool, and run a DAG that triggers a Fabric pipeline.
  • Version control: connect the workspace to a branch, change a notebook in Fabric and in Git, and resolve the conflict on update.
  • Database projects: change the Warehouse project in code, build it to a .dacpac, update Dev from Git and promote it; then make a publish stop on possible data loss (lifecycle lab, steps 5–6).
  • Deployment pipelines: promote Dev to Test with a deployment rule that changes the Lakehouse a notebook points to; then compare the stages (lifecycle lab, steps 3–4).
  • Workspace-level access: sign in as a Viewer and as a Contributor; list what each can open, edit, run and read through T-SQL (security lab, exercise 1).
  • Item-level access: share a Warehouse with Read only, grant one table in T-SQL, then share a Lakehouse and compare Read with ReadAll (security lab, exercises 2 and 7).
  • Row-, column-, object- and file-level access: implement RLS with a security predicate, grant a column list, grant a view instead of a table, and restrict a folder with a OneLake security role; test as two users (security lab, exercises 3–5).
  • Dynamic data masking: mask an email column, query it as an unprivileged user and as a Contributor, then grant UNMASK and query again (security lab, exercise 6).
  • Sensitivity labels: label a Lakehouse, create a downstream item, and check which items inherit the label.
  • Endorsement: promote one item and certify another; note who is allowed to certify and where endorsement shows.
  • Pipeline or notebook: take three real tasks (copy a table, apply business rules, call an API) and justify the tool for each in one sentence.
  • Schedules and event-based triggers: schedule the Lab 01 pipeline, then add a trigger on file arrival in OneLake and test it with a new file.
  • Orchestration with parameters and dynamic expressions: pass load_date from a parent pipeline into a notebook through Invoke Pipeline, build a file path with an expression, and rerun for another date.

Ingest and transform data

  • Full and incremental loads: build a watermark load, run it twice, confirm the second run moves nothing, and recover after a failed run without duplicates.
  • Dimensional model: build dim_customer with surrogate keys and SCD type 2 from the Lab 01 customers file; change one customer’s country and check history.
  • Streaming loading pattern: design where events land (Eventhouse, Lakehouse or both) and why; then implement the simplest version.
  • Data store choice: for five workloads (files, star schema, logs, telemetry, operational copy) choose Lakehouse, Warehouse or Eventhouse and write the reason.
  • Dataflows, notebooks or T-SQL: implement the same cleaning step three ways and compare effort, capacity usage and source control.
  • Shortcuts: create a shortcut to another Lakehouse or to ADLS, query it, then remove the identity’s access and read the error.
  • Mirroring: mirror an Azure SQL table, change rows in the source, and verify replication status and latency.
  • Pipelines: load a CSV with a parameterized Copy activity, with the source path and destination table coming from parameters.
  • PySpark, SQL and KQL: write the same filter and aggregation in all three languages against the same data.
  • Denormalize: join sales orders and order lines into one wide table, and check row counts before and after.
  • Group and aggregate: produce daily revenue by country with groupBy, GROUP BY and KQL summarize.
  • Duplicate, missing and late data: inject duplicate keys, nulls and a row dated last week; dedupe with row_number, handle nulls explicitly, and MERGE the late row.
  • Streaming engine choice: write when you would use Eventstream processing, KQL update policies or Spark structured streaming for the same source (decision table).
  • Eventstreams: build an Eventstream from a custom endpoint or sample source into an Eventhouse, with one filter and one derived column (guide, steps 1–4).
  • Spark structured streaming: stream JSON files into a Delta table with a checkpoint, stop it, add files and restart (guided example).
  • KQL: write queries that filter, project, extend, summarize by time bin and join to a lookup table (seven exercises).
  • Windowing functions: produce counts per 5-minute tumbling and hopping window with the Eventstream Group by operation, then the tumbling equivalent in KQL with bin() (windowing exercise).

Monitor and optimize an analytics solution

  • Monitor ingestion: run the Lab 01 pipeline and find its duration, rows copied and activity history in the Monitoring hub.
  • Monitor transformation: log rows in and out per notebook, and compare one run to the previous baseline.
  • Monitor semantic model refresh: build a small semantic model, refresh it, fail it on purpose, and read the refresh history.
  • Configure alerts: create an Activator alert on a failed pipeline run or on a KQL threshold and trigger it.
  • Pipeline errors: point a Copy activity at a missing file, read the error output, and fix it with a retry and a guard.
  • Dataflow errors: break a Dataflow Gen2 step with a data type change and trace it in refresh history.
  • Notebook errors: cause a schema mismatch on write, read the Spark error, and fix it without dropping data.
  • Eventhouse errors: ingest events whose schema doesn’t match the table mapping, and find the ingestion failure.
  • Eventstream errors: send malformed JSON into an Eventstream and locate the error in its data insights.
  • T-SQL errors: cause a permission error, a data type conversion error and a blocked statement in a Warehouse; resolve each.
  • Optimize a Lakehouse table: create many small files, measure a query, run OPTIMIZE (with V-Order), and measure again.
  • Optimize a pipeline: compare a sequential ForEach with a parallel one, and adjust Copy parallelism; record durations.
  • Optimize a data warehouse: compare a query before and after statistics updates and a better data type, then check result set caching.
  • Optimize eventstreams and eventhouses: compare query cost with and without a time filter, and review caching and retention policies.
  • Optimize Spark performance: create a skewed join, diagnose it in the Spark UI, and fix it with broadcast or repartitioning.
  • Optimize query performance: take one slow query in each engine (SQL endpoint, Warehouse, KQL) and make it measurably faster.

SQL, PySpark and KQL readiness

Microsoft expects all three. These matrices say what “comfortable” means for me and where Javi Builds has, or lacks, material.

SQL (T-SQL in Warehouse and SQL analytics endpoint)

Skill Must be comfortable with Javi Builds resource
Filters WHERE, NULL handling, predicates on dates WHERE, NULL
Joins INNER, LEFT, duplicate rows from joins SQL JOINs explained, duplicate rows
Aggregation GROUP BY, HAVING, aggregate functions GROUP BY, WHERE vs HAVING
Window functions ROW_NUMBER, RANK, LAG, running totals Gap: no dedicated SQL lesson yet
MERGE and upsert MERGE semantics, idempotent upserts Incremental loads (MERGE within a load pattern)
Fabric Warehouse T-SQL Schemas, CTAS, cross-database queries, GRANT First Fabric Warehouse with T-SQL
Optimization basics Statistics, data types, reading plans Tuning workflow, tuning checklist (SQL Server engine)

PySpark

Skill Must be comfortable with Javi Builds resource
DataFrames select, filter, withColumn, schema Explore data with PySpark, select and filter
Reads and writes CSV, JSON, Delta; save modes Read and write Delta tables, Delta read/write patterns
Delta MERGE, time travel, maintenance Delta for SQL engineers, Delta MERGE performance
Transformations Bronze to Silver to Gold logic Lab 01, notebook tutorial
Joins and aggregation Join types, groupBy, window functions Joins, aggregations, window functions
Partitioning When to partition, file sizes Partitioning checklist, partitioning strategies
Performance Shuffles, skew, caching, sessions Make notebooks faster, PySpark performance
Structured streaming readStream, writeStream, checkpoints, triggers Structured Streaming in brief (one guided example)

KQL

Skill Must be comfortable with Javi Builds resource
Filtering where, take, time ranges with ago() KQL cheat sheet: filter
Shaping project, extend KQL cheat sheet: shape columns
Aggregation summarize ... by, count(), dcount() KQL cheat sheet: summarize
Joins join kinds, lookup KQL cheat sheet: joins
Time windows bin(), make-series, ordering by time KQL cheat sheet: time windows
Eventhouse scenarios KQL databases, tables, update policies, materialized views Real-Time Intelligence guide (docs-based); update policies from Microsoft Learn

The KQL cheat sheet covers these on one practice dataset, with a SQL-to-KQL mapping and seven exercises; the Real-Time Intelligence guide applies them to live events. The KQL reference is the source of truth for the full language.

Troubleshooting preparation

Diagnosing is where hands-on experience shows. For each scenario: cause it in a test workspace, read the evidence before you search, then fix it and write down the signal that pointed to the cause.

Scenario Cause it safely Evidence to read Javi Builds resource
Pipeline failure Wrong path in a Copy activity Activity output and error in run history Debug Fabric pipelines
Notebook failure Schema mismatch on a Delta write Spark error, cell output, Spark UI Debugging pipelines and notebooks
Permissions Give a restricted reader ReadAll, or mistype an RLS mapping Effective roles in Manage OneLake security, USER_NAME() Security lab: break and fix
Shortcut failure Revoke the target identity’s access Shortcut error in the Lakehouse explorer Gap: Microsoft Learn (shortcuts)
Dataflow error Change a column type upstream Dataflow refresh history Gap: Microsoft Learn
T-SQL error Conversion error or missing permission Error number and message Safe UPDATE and DELETE
Eventstream or Eventhouse problem Renamed field, wrong mapping, skewed timestamps Data preview, null counts, ingestion time vs event time Real-Time Intelligence guide: break and fix (docs-based)
Spark performance issue Skewed join or many small files Spark UI stages, file counts Make notebooks faster, performance troubleshooting
Capacity pressure Run many sessions at once Capacity Metrics app, throttling Capacity saturation runbook
Warehouse performance issue Query with stale statistics or wide types Query insights, plan Gap: Microsoft Learn (Warehouse performance)

Evidence of readiness

Reading doesn’t prove readiness; something you built, broke or measured does. Keep this evidence in your study notes or repository. Without it, don’t score a readiness check at 3 or 4.

Skill area Evidence I should have
Workspace settings Notes on the settings that matter, with notebook start time before and after a change
Lifecycle management A Git repository with history, and one deployment to Test that uses a rule
Security and governance A two-user access test showing what each user could and couldn’t read, and through which engine
Orchestration A parameterized pipeline run for two dates, and one diagnosed failure
Loading patterns A watermark load whose rerun and replay give the same row counts
Batch data One transformation in SQL and PySpark with matching results, and a deduplicated table
Streaming data A working Eventstream-to-Eventhouse flow and five KQL queries written without notes
Monitoring A run’s evidence compared with a baseline, and one alert that fired
Identify and resolve errors Troubleshooting notes for one failure per engine: symptom, evidence, cause and fix
Optimize performance A before/after measurement and a paragraph on why the change worked

Add a short written answer to each study card’s Explain question. If you can’t write it in a paragraph without notes, that card isn’t done.

Practice assessment strategy

Microsoft now recommends its newer Practice Assessment on AI Skills Navigator, which more closely matches the exam experience; the legacy Learn assessment is no longer updated. I use it as a diagnostic:

  1. Take a baseline in week 1, before studying, without looking anything up.
  2. Record weak domains and skill groups, not individual questions.
  3. Practise those skills with the exercises above until you can do them without notes.
  4. Retake after a gap, not the next day, so the result measures skill rather than short-term memory.
  5. Don’t memorize questions. If you recognize a question, the result tells you less. Explain why each wrong option is wrong instead.

Exam readiness checklist

The coverage matrix above says what Javi Builds teaches for each objective. This checklist asks a different question, about you: am I only familiar with this objective, or can I actually perform and troubleshoot it? It is the last step of the loop: study the blueprint, practise with the lab track and exercises, then assess readiness here.

Readiness scale

Level Meaning What it looks like
0 Not studied I haven’t looked at it yet.
1 Understand the concept I can explain it, but I haven’t done it in Fabric.
2 Can do it with notes I can do it while following a tutorial or my notes.
3 Can do it independently I can do it from a blank workspace without notes.
4 Can troubleshoot it and explain the tradeoffs I can fix it when it breaks and say why I’d choose it over the alternatives.

How to use it: score it after the hands-on work, not before. Give each check a level in your own notes, and tick the box only at level 3 or 4, when you have the matching evidence. Each study card links to its domain’s checks here. Anything at 0 or 1 goes into next week’s plan in the study roadmap. The boxes work in the browser but aren’t saved; print the page or copy the list to keep a record.

Checks marked Known gap are objectives where Javi Builds has no material yet. Study them from the linked Microsoft Learn page and the learning paths, and expect to start lower on the scale. Checks that point to the security lab, the lifecycle lab or the Real-Time Intelligence guide link to docs-based guided practice: the steps are right to follow, but compare your results with Microsoft Learn rather than treating the lab’s expected results as confirmed.

Domain 1: Implement and manage an analytics solution (30–35%)

Workspace settings

  • I can set a workspace’s default Spark pool, runtime and environment, and explain how each choice affects notebook start time. Practise: notebook startup time, runtime comparison.
  • I can find the domain, OneLake and data workflow settings of a workspace and say what each one controls. Practise: workspace settings cheat sheet (data workflows are now the Apache Airflow job).

Lifecycle management

  • I can connect a workspace to Git and explain what is and is not version controlled. Practise: Connect Fabric to Git.
  • I can promote content from Dev to Test with a deployment pipeline and a deployment rule. Practise: lifecycle lab, steps 3–4; fabric-cicd for code-first deployment.
  • I can manage a Warehouse as a SQL database project: change it in code, build it and deploy it. Practise: lifecycle lab, steps 5–6.

Security and governance

  • I can configure Fabric workspace access and explain the difference between Admin, Member, Contributor and Viewer. Practise: Security architecture.
  • I can share one item with the right permissions, such as ReadData or ReadAll, without granting a workspace role. Practise: security lab, exercise 2.
  • I can implement row-, column- and object-level security in T-SQL and a OneLake security role for files, then prove each one as a second user. Practise: security lab, exercises 3–5 and 7.
  • I can mask a column with dynamic data masking and explain who still sees the real values. Practise: security lab, exercise 6.
  • I can apply a sensitivity label, explain how it is inherited, and choose between promoting and certifying an item. Practise: Governance.

Orchestration

Domain 2: Ingest and transform data (30–35%)

Loading patterns

Batch ingestion and transformation

Streaming

Domain 3: Monitor and optimize an analytics solution (30–35%)

Monitoring

Errors

Optimization

My readiness

Fill this in after scoring the checks above. Use the lowest level in each domain, not the average: one weak skill group is what the exam finds.

Domain My assessment (0–4)
Implement and manage ___
Ingest and transform ___
Monitor and optimize ___
  • Strongest domain: ______
  • Weakest domain: ______
  • Next thing I need to practise: ______

Final exam-readiness checks

  • I have reviewed all current DP-700 objectives.
  • I have completed hands-on practice in all three domains.
  • I can work in SQL without relying entirely on examples.
  • I can work in PySpark without relying entirely on examples.
  • I can perform the core KQL operations required by the blueprint.
  • I can troubleshoot pipeline and notebook failures.
  • I can explain why I would choose a pipeline, a notebook or Dataflow Gen2.
  • I can explain batch vs streaming choices.
  • I can apply Fabric security controls.
  • I can monitor and optimize a Fabric workload.
  • I completed the current Microsoft Practice Assessment.
  • I reviewed the Microsoft exam sandbox.
  • I documented my weak areas and practised them.

Before booking, check the exam logistics too: ID, testing setup, time zone, and registration on a personal Microsoft account.

Microsoft Learn foundation

These are the five official self-paced learning paths for DP-700: 26 modules and about 26.5 hours in total, according to the Microsoft Learn catalog in November 2026. They are the foundation; everything above sits on top of them.

Learning path Modules Duration
Ingest data with Microsoft Fabric 4 about 4 h 25 min
Implement a Lakehouse with Microsoft Fabric 7 about 7 h
Implement Real-Time Intelligence with Microsoft Fabric 5 about 5 h 30 min
Implement a data warehouse with Microsoft Fabric 7 about 6 h 40 min
Manage a Microsoft Fabric environment 3 about 3 h

Microsoft Learn teaches the platform. Javi Builds adds practice, troubleshooting, architecture decisions and study organization. Microsoft’s DP-700 exam prep videos are a useful review once the paths are done.

Keeping this guide current

Microsoft changes the skills measured several times a year. When the certification page shows a new “Last Updated” date, I recheck every objective in this guide, update the coverage matrix and the exercises, and change the verification date at the top.

Last verified against Microsoft Learn: November 2026, against the official study guide and the certification page.