Final review

Exam tips & caveats

The last-mile page. Numbers to memorize, decision trees to internalize, and the traps that decide borderline results. Read this the evening before.

How DP-700 is actually scored

700 of 1000 is a scaled score — it is not 70% of questions correct. Questions are weighted, and there is no penalty for guessing, so never leave anything blank. The three domains are equally weighted at 30–35% each, so a weak domain costs you roughly a third of the exam.

Key numbers to memorize

Item	Value	Why it matters
Passing score	700 / 1000	Scaled, not a percentage
Exam duration	100 minutes	~120 min seat time including check-in
Domain weights	30–35% each	All three equal — no domain to skip
Capacity unit → Spark	1 CU = 2 Spark vCores	F64 = 128 base vCores
Spark burst factor	3×	F64 bursts to 384 Spark vCores
Free-viewer threshold	F64	Below it, consumers need Power BI Pro
Background smoothing window	24 hours	Interactive smooths over 5 minutes
Throttling ladder	10 min → 60 min → 24 h	Interactive delay → interactive rejection → background rejection
Fabric trial	60 days	Behaves like an F64 for feature gating
VACUUM default retention	7 days (168 hours)	Going below breaks time travel
Delta checkpoint interval	Every 10 commits	Log compaction into Parquet
Deployment pipeline stages	Up to 10	Typically Dev → Test → Prod
Airflow extra node	+3 workers each	Concurrency scaling for DAGs
Shortcut target types	OneLake, ADLS Gen2, S3 (+compatible), GCS, Dataverse	Know which are cross-cloud
Git providers	Azure DevOps, GitHub	Nothing else natively

Numbers drift — verify before exam day

Fabric limits, SKU tables and preview/GA status change frequently. Treat these as the values to reason with, and spot-check the volatile ones (mirroring sources, OneLake security capabilities, capacity limits) against Microsoft Learn shortly before you sit.

Master decision trees

Where should this data live?

flowchart TD S([Storage decision]) --> Q1{Access pattern} Q1 -->|"T-SQL read AND write, stored procs"| WH["Warehouse"] Q1 -->|"Spark, files, mixed engines"| LH["Lakehouse"] Q1 -->|"High-volume events, time-series"| EH["Eventhouse"] Q1 -->|"Already in a lake, don't duplicate"| SC["OneLake shortcut"] Q1 -->|"Live replica of an operational DB"| MR["Mirroring"]

How should I transform it?

flowchart TD S([Transform decision]) --> Q1{Who and how big?} Q1 -->|"Analyst, no code"| DF["Dataflow Gen2"] Q1 -->|"Engineer, very large or complex"| NB["Notebook / PySpark"] Q1 -->|"SQL developer, data in Warehouse"| TS["T-SQL / CTAS / stored proc"] Q1 -->|"Telemetry in an Eventhouse"| KQ["KQL / update policy"] Q1 -->|"Streaming with big joins"| SS["Spark structured streaming"]

How should I orchestrate it?

flowchart TD S([Orchestration decision]) --> Q1{One step or many?} Q1 -->|"A single transform"| ONE["Dataflow Gen2 or notebook
on its own schedule"] Q1 -->|"Multiple ordered steps,
conditions, loops, retries"| PIPE["Data pipeline"] Q1 -->|"Existing Airflow DAGs,
Python-defined dependencies"| AF["Apache Airflow job"] Q1 -->|"React to a data condition"| ACT["Activator rule"] PIPE --> TRG{Trigger} TRG -->|"Time-based"| SCH["Schedule"] TRG -->|"File lands / job completes"| EVT["Event trigger via Real-Time hub"]

Which security control?

flowchart TD S([Security decision]) --> Q1{Granularity} Q1 -->|"Whole workspace"| WR["Workspace role"] Q1 -->|"One item"| IP["Item permission / share"] Q1 -->|"Certain rows, SQL only"| RLS["RLS security policy"] Q1 -->|"Certain rows, every engine"| OLS2["OneLake security"] Q1 -->|"Certain columns"| CLS["CLS — GRANT/DENY"] Q1 -->|"Object must be invisible"| OLS["OLS in semantic model"] Q1 -->|"Show partial values only"| DDM["Dynamic data masking"] Q1 -->|"A folder in a Lakehouse"| FLS["OneLake data access role"]

Top exam traps

The Lakehouse SQL analytics endpoint is read-only. No INSERT/UPDATE/DELETE/MERGE via T-SQL. Writes need Spark, or a Warehouse.
OPTIMIZE ≠ VACUUM. OPTIMIZE compacts small files; VACUUM deletes unreferenced old files. Neither does the other's job.
VACUUM below 7 days breaks time travel and can break running readers. Spark blocks it unless you disable the safety check.
V-Order ≠ Z-Order. V-Order optimizes within files at write time; Z-Order co-locates across files during OPTIMIZE.
Mirroring ≠ shortcuts. Mirroring replicates via CDC (one-way, read-only in Fabric); shortcuts point at data and copy nothing.
Git and deployment pipelines move definitions, never data. No rows are promoted, ever.
Deployment rules go on the target stage, not the source. This is the classic wrong click.
Member can reshare; Contributor cannot. That single difference decides most role questions.
ReadAll bypasses SQL-layer security. RLS, CLS and DDM are enforced by the SQL engine — direct OneLake/Spark readers see raw data. Cross-engine enforcement means OneLake security.
DDM is not a security boundary. UNMASK, elevated permissions or inference through WHERE clauses defeat it.
OLS exists only in semantic models, and its point is total invisibility — not an access error.
Warehouse constraints are NOT ENFORCED. A primary key will not stop duplicate inserts; dedupe in the load.
Dataflow Gen2 memory/timeout → staging and query folding, not a larger capacity.
Streaming needs a checkpoint and (for stateful aggregations) a watermark. No checkpoint → reprocessing on restart. No watermark → unbounded state and eventual crash.
Tumbling counts each event once; hopping and sliding overlap. A hopping window with hop = size is a tumbling window.
AQE is on by default. Answers that manually tune shuffle partitions or hand-fix skew are usually distractors.
coalesce() cannot fix skew — it only reduces partition count without a shuffle. repartition() rebalances.
Broadcasting too large a table just relocates the OOM to the driver.
Caching policy ≠ retention policy. Past cache = slow. Past retention = gone.
Query acceleration costs extra CUs and introduces slight staleness — it buys speed, not freshness.
Shortcut data is excluded from OPTIMIZE and VACUUM on the hosting Lakehouse.
Shortcut access needs permission on both sides — the source system and OneLake.
Each streaming consumer needs its own consumer group, or readers silently split the events.
%pip install is session-only. Persistent libraries belong in an Environment.
Direct Lake has no data refresh to schedule — but it can silently fall back to DirectQuery.
dropDuplicates keeps an arbitrary row. "Keep the latest" needs row_number() over a window.
Starter pool = fast start, fixed size. Custom pool = your size, cold start.
Promotion is self-service; certification is allow-listed.

Pairs people mix up

This	Not this	The distinction in one line
OPTIMIZE	VACUUM	Compacts vs deletes
V-Order	Z-Order	Inside files at write vs across files at optimize
Shortcut	Mirroring	Points at data vs replicates data
Lakehouse	Warehouse	Spark + read-only SQL vs full read/write T-SQL
RLS	OneLake security	SQL engine only vs every engine
CLS	OLS	Permission error vs completely invisible
DDM	CLS	Obfuscated but present vs genuinely denied
Member	Contributor	Can reshare vs cannot
Sensitivity label	Endorsement	How confidential vs how trustworthy
Promoted	Certified	Anyone vs allow-listed certifiers
Git integration	Deployment pipeline	Version and review vs promote between stages
Database project	Deployment pipeline	Schema-object level vs whole-item level
Data pipeline	Airflow job	Fabric-native visual vs Python DAGs and Airflow operators
Tumbling	Hopping	No overlap vs overlapping by hop
Caching policy	Retention policy	How fast vs how long it exists
Monitoring hub	Capacity Metrics app	Did the run fail vs what burned the CUs
coalesce()	repartition()	No shuffle, reduce only vs full shuffle, rebalance
%run	notebookutils.notebook.run()	Same session, shares variables vs separate job, returns a value
SCD Type 1	SCD Type 2	Overwrite vs new row with validity dates
Starter pool	Custom pool	Warm and fixed vs sized and cold

Question-type strategy

Type	How to attack it
Case study	Read the requirements and constraints sections first, then the questions, then re-read only the relevant paragraph. Constraints ("must not copy data", "analysts have no coding skills", "must survive re-runs") are the answer keys.
Build list / ordering	Anchor the first and last steps — they are usually obvious — then order the middle by dependency. Watch for steps that are plausible but not required; extra steps are wrong.
Hotspot / dropdown	Each dropdown is scored separately. Answer the ones you know confidently first; don't let one uncertain field make you second-guess the rest.
Yes/No statement sets	Evaluate each statement independently against the original scenario. The same scenario is often repeated with a different proposed solution — re-read it each time.
Code reading	You mostly need to spot what is missing or wrong: no checkpoint, no watermark, wrong output mode, coalesce where repartition is needed, MERGE condition that misses the current-row filter.
"Which tool" questions	Find the persona and the hard constraint. "No-code" excludes notebooks. "Stored procedure" excludes Lakehouse. "Without copying data" excludes mirroring and copy activity.

Time management

100 minutes across roughly 40–60 items leaves under two minutes each. Do a fast first pass answering everything you know, flag the rest, and come back. Case studies are worth reading carefully but should not consume half your clock — if a case study appears in a locked section, finish it before moving on, because you may not be able to return.

Scenario → answer lookup

Scenario	Answer
SQL developers need stored procedures and transactions	Warehouse
Engineers need PySpark and SQL over the same data, plus raw files	Lakehouse
Millions of telemetry events, sub-second dashboards	Eventhouse / KQL database
Query ADLS/S3 data without copying it	OneLake shortcut
Near real-time replica of Azure SQL DB with no ETL	Mirroring
Simple recurring incremental copy, minimal authoring	Copy job
Analyst builds a transform with no code	Dataflow Gen2
Multi-step workflow with branching and retries	Data pipeline
Migrating existing Airflow DAGs	Apache Airflow job
Run a job when a file lands in OneLake	Event-based trigger
Alert and act when a metric crosses a threshold	Activator
Load only rows changed since the last run	Watermark + MERGE
Re-running a load must not duplicate rows	MERGE on the business key
Track full history of dimension changes	SCD Type 2
Keep only the newest row per key	row_number() over a window
Fact arrives before its dimension row	Inferred member placeholder
Count each event once per 5-minute block	Tumbling window
15-minute average reported every 5 minutes	Hopping window
Group activity until 30 minutes idle	Session window
Enrich a stream with a huge batch dimension	Spark structured streaming
Route one stream to two destinations, no code	Eventstream
Faster KQL over shortcut data	Query acceleration
Restrict rows for SQL consumers	RLS
Restrict rows for Spark consumers too	OneLake security
Hide a column from analysts	CLS
Table must not appear at all	OLS
Show only the last four digits	DDM partial()
Restrict one Lakehouse folder	OneLake data access role
Build items but never share them	Contributor
Mark the authoritative semantic model	Certified endorsement
Review changes before they reach Prod	Git + pull request
Promote items Dev → Test → Prod	Deployment pipeline
Warehouse schema in source control with drift detection	Database project
Who exported this report?	Purview audit log
What is consuming the capacity?	Capacity Metrics app
Why did last night's run fail?	Monitoring hub
Too many small files	OPTIMIZE
Slow filters on specific columns	Z-Order
Storage bloat from old versions	VACUUM
One task far slower than the rest	Data skew — salt / AQE
Slow join with one tiny table	Broadcast join
Dataflow Gen2 out of memory	Staging + query folding
Old KQL data slow / old KQL data gone	Caching policy / retention policy

Pre-exam checklist

If you can answer every one of these out loud without notes, you are ready.

Can you state the Lakehouse vs Warehouse vs Eventhouse decision and the read-only endpoint limitation?
Can you describe the watermark incremental pattern end to end, and why MERGE makes it idempotent?
Can you implement SCD Type 2 and explain why it takes two MERGE passes?
Can you name all six security layers and which engine enforces each?
Do you know why ReadAll defeats RLS/CLS/DDM, and what to use instead?
Can you distinguish OPTIMIZE, VACUUM, V-Order and Z-Order in one line each?
Do you know the capacity throttling ladder and which tool diagnoses it?
Can you configure Spark, domain, OneLake and Apache Airflow workspace settings, and say what each controls?
Can you choose between Dataflow Gen2, notebook, pipeline and Airflow job from a scenario?
Do you know Git vs deployment pipelines vs database projects, and that none of them move data?
Can you name the five window types and pick one from a description?
Do you know why streaming needs a checkpoint and a watermark?
Can you choose between native table, accelerated shortcut and standard shortcut in RTI?
Can you triage errors across pipelines, dataflows, notebooks, Eventhouse, Eventstream, T-SQL and shortcuts?
Do you know the three query insights views and when to use each?
Can you read a Spark UI symptom and name the fix — skew, shuffle, spill, small files, cold start?

The night before

Do not learn anything new. Re-read the traps list and the confusable pairs table, take the free Microsoft practice assessment one final time, and sleep. Recognition speed matters more on this exam than depth of recall.

Disclaimer

These notes are an independent study aid for learning purposes only, not affiliated with or endorsed by Microsoft, and contain no exam content. Microsoft Fabric changes rapidly — always verify against the official documentation and the current DP-700 study guide.