DBX-DEP Study Guide: The Professional Exam Rewards the Smallest Action That Fixes the Problem
At associate level, a Databricks question usually has one working answer and three that do not work. At professional level, often two or three options would work, and the exam wants the one that does the least: reprocesses the least data, grants the least access, rewrites the least code, costs the least compute. Learning to rank working options by how narrow they are is the skill this guide is built around, domain by domain.
Study guide · Databricks Certified Data Engineer Professional (DBX-DEP)

The exam
60 scored multiple-choice questions (plus unscored ones) in 120 minutes. Databricks does not publish the pass mark; check the official exam page. The exam guide of 9 October 2026 lists nine sections; the exam page still shows an older ten-section outline and 59 questions. This question bank follows the newer guide:
| Section | Weight |
|---|---|
| Developing Code for Data Processing using Python and SQL | 23% |
| Cost & Performance Optimization | 15% |
| Data Ingestion & Acquisition · Data Manipulation | 12% each |
| Monitoring and Alerting · Debugging and Deploying | 10% each |
| Ensuring Data Security and Compliance | 8% |
| Data Governance · Data Modeling | 5% each |
The bank reflects how hands-on this exam is. Of the 300 DBX-DEP questions in this question bank, about 88% (263) quote code, SQL or a setting in the question or its options, and about half (152) are troubleshooting questions: something is slow, wrong, failing or too expensive. If you have only read about Databricks, this is the exam where that shows.
The narrowest recovery
When something fails, the options usually form a ladder from "redo one step" to "redo everything". The professional answer is the lowest rung that restores a correct state.
| Situation | Narrow fix | Too wide |
|---|---|---|
| Two tasks of a job failed | Repair run: only unsuccessful tasks and their dependants, with current settings and optional parameter overrides. | Run the whole job again. |
| One or two pipeline tables failed after a transient error | Refresh failed tables. | Full refresh of the pipeline. |
| A new source must feed an existing streaming table | Add an append flow, with a one-time ONCE flow for the backfill. | Rewrite the query as a UNION and fully refresh. |
| Change one setting of a job via the CLI | jobs update with the changed fields. | jobs reset, which replaces all settings with what you send. |
The "too wide" option is not just slower. A full refresh clears streaming tables and their checkpoints and replays what the source still holds. If a Kafka topic keeps seven days and the table holds two years, history is gone. Setting pipelines.reset.allowed to false on such a table blocks full refreshes.
Going deeper: why foreachBatch needs its own idempotency
Structured Streaming writes the planned batch to the checkpoint's offset log before it runs, and to the commit log after it finishes. If the query dies between the two, the restart replays the same batch with the same batchId. A built-in Delta sink handles that for you. Inside foreachBatch you write to arbitrary places, so Spark only promises at-least-once. For Delta writes inside the function, pass txnAppId and txnVersion bound to batchId; Delta then skips a write it has already committed for that pair. Without it, a replayed batch appends its rows twice, and the "duplicates after a restart" stem is about exactly this.
Repair run: only failed tasks and their dependants
Refresh failed tables
An append flow, with a one-time ONCE flow for the backfill
jobs update with the changed fields, not jobs reset
Pick the lowest rung that restores a correct state; a full refresh can lose history
The narrowest permission
Security questions list four grants that would all let the person do the job. Pick the lowest rung that covers every duty in the stem.
- Someone who must start, cancel and read logs of a job:
CAN MANAGE RUN, notCAN MANAGE. - A service principal that only refreshes one materialized view:
USE CATALOG,USE SCHEMAandREFRESHon that view, notSELECTorMODIFYon the schema. ALL PRIVILEGESdoes not includeMANAGE.- Many tables with a
piitag: one ABAC policy on governed tags at the catalog or schema, not a mask on every table. Keep the mask and filter functions small SQL functions, because they run for every row.
Compliance has the same shape. A plain sha2 of a phone number is pseudonymisation, not anonymisation, because a small value space can be hashed in full. A DELETE with deletion vectors only hides rows; physically removing them needs REORG TABLE ... APPLY (PURGE) to rewrite the files, then VACUUM to remove the older files that still hold the data. A change data feed keeps deleted values too, for as long as its table versions are retained.
The narrowest code change
The biggest section, at 23%, is about code. The options often differ by one line, so read for the line that changes behaviour:
- A Series-to-Series pandas UDF that loads a large model in its body loads it once per batch. The Iterator-of-Series form can load it once and reuse it for every batch in the iterator.
- A window with
ORDER BYand no frame defaults toRANGEup to the current row, so ties share a running total. - VARIANT paths are case-sensitive; JSON string paths are not, unless you use brackets.
try_parse_jsonreturns NULL whereparse_jsonfails the batch. - In a declarative pipeline,
pivot()is not supported because it must read the data eagerly to work out its output schema; use conditional aggregation. AUTO CDC(formerlyAPPLY CHANGES) orders changes bysequence_by; a column added withcurrent_timestamp()records processing time and lets old values win.
Beginner tip: before your first practice set, open a notebook and run SELECT * FROM system.lakeflow.job_run_timeline LIMIT 20 and SELECT * FROM system.billing.usage LIMIT 20 (an admin may need to grant access). Find one long run that spans several rows, and one usage row with a job_id. Monitoring questions assume you know these tables have hourly slices and that the final result_state sits only on the row that ends a run. Seeing it once is faster than memorising it.
The narrowest cost fix
Cost and performance questions reward evidence before action. Find where the time goes, then change only that:
- Spark UI for a classic cluster stage: skew when the maximum task time is far above the 75th percentile, spill statistics when memory ran out, timeline gaps with a busy driver when non-Spark code is the bottleneck.
- Query profile for SQL on a warehouse: insights such as
DATA_SPILLorEXCESSIVE_QUEUE_TIMEsay whether to change the query, the layout or the warehouse. - System tables for many runs over time. Remember that
usage_metadata.job_idis empty when a job runs on all-purpose compute, and that thejobstable keeps a row for every edit, so join to the latest row only.
Layout: Liquid Clustering for new tables (it cannot be combined with partitioning or ZORDER), CLUSTER BY AUTO and predictive optimization for managed tables, deletion vectors for MERGE jobs that touch few rows in many files.
Going deeper: why a materialized view sometimes recomputes everything
A materialized view promises that its content equals the batch query over the current inputs. Incremental refresh is an optimisation on top of that promise, available only on serverless pipelines, and even there it is cost-based: if the engine estimates that a full recompute is cheaper or the query shape cannot be maintained incrementally, it recomputes. The result is the same either way. Summing FLOAT or DOUBLE columns gives order-dependent results, so such a view is planned as a full refresh; casting to a decimal type makes incremental planning possible. The pipeline event log shows why a refresh was full. When a stem asks why a refresh did a full recompute on a classic pipeline, the answer is the compute type, not the query.
A study order
- Lakeflow Spark Declarative Pipelines in depth: streaming tables versus materialized views, flows, AUTO CDC, expectations, refresh options.
- Structured Streaming: watermarks, output modes,
foreachBatch, Kafka and Auto Loader recovery. - Python and SQL: UDF types, window frames, VARIANT, testing with
assertDataFrameEqual. - Monitoring and cost: system tables, event log, Jobs API paging, query profile, Spark UI.
- Declarative Automation Bundles (formerly Databricks Asset Bundles) and Git folders, permissions and ABAC, then timed mixed sets of 60.
Practise
Practise in the question bank: every question explains each option, right and wrong. Start with the domain you just studied, then take a timed mock exam.
- DBX-DEP exam page · All 360 DBX-DEP questions · Timed mock exam · 25-day study plan
- By domain: Developing Code for Data Processing using Python and SQL · Data Ingestion & Acquisition · Data Manipulation · Monitoring and Alerting · Cost & Performance Optimization · Ensuring Data Security and Compliance · Data Governance · Debugging and Deploying · Data Modeling
Section weights as listed in the Databricks exam guide for the Data Engineer Professional. Features such as incremental refresh, ABAC and system tables change often; check the current exam guide and documentation.