Fabric CI/CD Deployment Checklist
What to check before, during and after promoting Microsoft Fabric items from Git to Test and Production.
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:
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?
| 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.
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?
| 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.
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.
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.
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.
| 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 |
| 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 |
| 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 |
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.
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.
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
Domain 2: Ingest and transform data
summarize and bin(), and build the same 1-minute window in the eventstream.Domain 3: Monitor and optimize an analytics solution
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. |
The exam describes scenarios. A memorized menu path doesn’t help if you can’t tell which tool the scenario needs.
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.
| # | 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.
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
.dacpac, update Dev from Git and promote it; then make a publish stop on possible data loss (lifecycle lab, steps 5–6).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
dim_customer with surrogate keys and SCD type 2 from the Lab 01 customers file; change one customer’s country and check history.groupBy, GROUP BY and KQL summarize.row_number, handle nulls explicitly, and MERGE the late row.bin() (windowing exercise).Monitor and optimize an analytics solution
Microsoft expects all three. These matrices say what “comfortable” means for me and where Javi Builds has, or lacks, material.
| 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) |
| 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) |
| 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.
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) |
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.
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:
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.
| 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.
Workspace settings
Lifecycle management
Security and governance
Orchestration
Loading patterns
Batch ingestion and transformation
Streaming
Monitoring
Errors
Optimization
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 | ___ |
Before booking, check the exam logistics too: ID, testing setup, time zone, and registration on a personal Microsoft account.
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.
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.