Databricks Certified Data Engineer Professional Practice Exam

What the Databricks Certified Data Engineer Professional exam covers

• Developing Code for Data Processing with Python and SQL149 questions
• Data Ingestion and Acquisition47 questions
• Data Transformation, Cleansing, and Quality69 questions
• Data Sharing and Federation33 questions
• Monitoring and Alerting69 questions
• Cost and Performance Optimization89 questions
• Ensuring Data Security and Compliance69 questions
• Data Governance47 questions
• Debugging and Deploying69 questions
• Data Modeling41 questions

Free Databricks Certified Data Engineer Professional practice test questions

A sample of 10 questions with answers and explanations. Sign up free to practice all 682.

1. Question 1Developing Code for Data Processing with Python and SQL

   A nightly job upserts a change batch into a Delta table. The engineer wants the job to be safe to re-run on the same batch without creating duplicates or double-applying updates. ```sql MERGE INTO customers t USING staged_changes s ON t.customer_id = s.customer_id WHEN MATCHED THEN UPDATE SET * WHEN NOT MATCHED THEN INSERT * ``` What property of this statement makes the re-run safe?

   • AThe merge condition matches on the key, so a repeated batch updates the same rows rather than appendingCorrect
   • BDelta Lake records the batch identifier internally and silently skips a merge it has already applied
   • CMERGE runs inside an implicit retry loop that detects and discards a duplicate source batch
   • DUPDATE SET * compares every column and becomes a no-op when the values are already identical
   ✓ Correct answer: A

   Idempotency here comes from the operation being keyed rather than append-only. On a re-run every source row matches the existing target row on customer_id, so it takes the UPDATE branch and writes the same values, leaving the table in the same logical state. Nothing is inserted twice because the NOT MATCHED branch no longer applies. This is why MERGE is preferred over INSERT for change batches: an append would add duplicates on every retry, and job retries are a normal part of operating a pipeline rather than an exceptional case.

   Why the other options are wrong

   • BDelta Lake does not record source batch identifiers or skip a merge it has seen before. Idempotency is a property of the keyed statement rather than something the engine tracks for you.
   • CMERGE does not run inside a retry loop and has no notion of a duplicate source batch. It executes the branches you wrote against whatever the source relation contains.
   • DUPDATE SET * assigns every column unconditionally and does not compare values first, so the row is rewritten. The result is the same logical state, which is why the re-run is safe, but the write is not skipped.
2. Question 2Developing Code for Data Processing with Python and SQL

   Two streams must be joined on a key, matching events that occur within an hour of each other. What must the query include for the join state to remain bounded?

   • AWatermarks on both streams and a time-range condition in the join predicateCorrect
   • BA watermark on the larger stream only, since the smaller one is fully buffered
   • CA trigger interval shorter than the matching window so state clears each batch
   • DComplete output mode, which discards join state after each result is emitted
   ✓ Correct answer: A

   A stream-stream join must buffer each side while waiting for a match on the other, so without a bound the state grows forever. Bounding it requires two things together: watermarks on both inputs so the engine knows how late each side may be, and a time-range condition in the join predicate so it can compute how long a row must be retained before no future match is possible. With both present, state older than that bound is evicted. Omitting either leaves the engine unable to prove a row can be discarded, so it keeps everything.

   Why the other options are wrong

   • BBoth sides are buffered in a stream-stream join, so both need watermarks. There is no notion of one side being small enough to hold entirely.
   • CTrigger interval controls how often micro-batches run and has no effect on how long join state is retained. State persists across triggers by design.
   • DOutput mode governs what the sink receives and does not manage join state. Complete mode is for aggregations and would not apply here.
3. Question 3Developing Code for Data Processing with Python and SQL

   A transformation applies a lookup that is expected always to match. Occasionally it does not, and the result carries nulls into a financial total. What is the appropriate handling?

   • AAssert the expectation explicitly and fail or quarantine, rather than letting nulls propagateCorrect
   • BCoalesce the missing values to zero so the total remains numerically complete
   • CUse an inner join so unmatched rows are dropped before the total is computed
   • DDocument the possibility so consumers know the total may be understated
   ✓ Correct answer: A

   The logic rests on an assumption that every row matches, and when that fails the correct response is to say so rather than to produce a plausible-looking wrong number. Asserting the expectation turns a silent understatement into a visible failure, and quarantining the unmatched rows preserves them for investigation while letting the rest proceed. Both alternatives that hide the problem, filling with zero or dropping the rows, produce a total that looks complete and is not, which is the outcome hardest to detect and most damaging when it reaches a report.

   Why the other options are wrong

   • BCoalescing to zero makes the total look complete while silently excluding real amounts, which is worse than a null because nothing indicates anything is missing.
   • CAn inner join drops the unmatched rows, again producing an understated total with no signal. It converts a visible null into an invisible omission.
   • DDocumenting the possibility puts the burden on every consumer to remember a caveat, and the report still shows a wrong number. Documentation is not a control.
4. Question 4Data Transformation, Cleansing, and Quality

   A pipeline enriches transactions with a customer attribute from a dimension. Some transactions have no matching customer. Which join preserves the transactions?

   • AA left join from transactions, leaving the attribute null where no customer matchesCorrect
   • BAn inner join, which is correct because a transaction without a customer is invalid
   • CA right join from the dimension, which preserves every customer and their transactions
   • DA full outer join, which preserves both sides and is therefore the safest default
   ✓ Correct answer: A

   Enrichment should not change the grain or the population of the fact table, so a left join from transactions is the correct shape: every transaction survives and the attribute is null where no match exists. That null is then visible and countable, which is what lets the team decide whether an unmatched rate is acceptable or indicates a broken dimension load. An inner join would silently drop those transactions, which is the most common way an enrichment step quietly loses revenue from a report.

   Why the other options are wrong

   • BAn inner join drops unmatched transactions, and whether that is valid is a business decision rather than a given. Even where the transaction is genuinely invalid, dropping it silently is worse than flagging it.
   • CA right join from the dimension preserves every customer including those with no transactions, which changes the result's grain and introduces rows that are not transactions at all.
   • DA full outer join preserves both sides and therefore introduces dimension-only rows into a transaction table, which corrupts the grain. Preserving more is not safer when it changes what the table means.
5. Question 5Data Sharing and Federation

   A shared table's schema is changed by the provider. What should the provider consider about recipients?

   • ARecipients depend on the shared shape, so a change is a breaking change to an external interfaceCorrect
   • BRecipients are insulated from schema changes, since the share presents a fixed snapshot of the schema
   • CRecipients receive the change automatically with no consequence, since Delta handles evolution
   • DRecipients must re-accept the share, which the platform enforces before any read succeeds
   ✓ Correct answer: A

   Recipients have written queries and pipelines against the shared shape, and unlike an internal consumer they cannot be coordinated with easily, may not be reachable at short notice, and are outside the provider's release process. That makes a schema change on a share a breaking change to a published interface, warranting notice, a deprecation period, and where possible sharing a view so the base table can evolve behind a stable projection. Treating it as an ordinary internal change is how a partner integration breaks without warning.

   Why the other options are wrong

   • BThe share exposes the table's current schema rather than a frozen snapshot, so changes propagate to recipients. Insulation is achieved by sharing a view, which is a deliberate design choice.
   • CAdditive evolution may be harmless for recipients selecting named columns and a rename, a type change or a removal is not. Assuming no consequence is what causes the breakage.
   • DNo re-acceptance is enforced on a schema change, so reads continue against the new shape and fail only where the recipient's query depended on what changed. Nothing prompts them.
6. Question 6Monitoring and Alerting

   A pipeline's owner leaves the team and its alerts continue firing into a channel nobody watches. What arrangement prevents this class of problem?

   • AAlerts routed to a team rather than an individual, with ownership reviewed periodicallyCorrect
   • BAlerts routed to a shared mailbox, so no individual dependency exists
   • CAlerts routed to more recipients, so at least one is likely to respond
   • DAlerts documented in the runbook, so a successor can find them
   ✓ Correct answer: A

   Individual routing creates a dependency that breaks on any departure, role change or extended absence, and nothing announces the break. Routing to a team, with an on-call rotation for anything urgent, means the destination survives personnel change. The periodic ownership review is the other half, because a team can also dissolve or transfer responsibility, and a scheduled review of which team owns which pipeline is what catches an alert whose owner no longer exists.

   Why the other options are wrong

   • BA shared mailbox removes the individual dependency and is the archetypal place alerts go unread, since nobody is specifically responsible for it. Diffuse ownership is not ownership.
   • CMore recipients dilutes responsibility further, since each assumes another will respond. It reliably reduces the chance anyone does.
   • DRunbook documentation helps a successor who is already looking and does nothing while the alerts fire into an unwatched channel. It is passive.
7. Question 7Cost and Performance OptimizationSelect all that apply

   A team reviews a dashboard whose queries each scan a 6 TB fact table. Which two changes reduce cost without changing what users see?

   • AIntroduce aggregate tables the dashboard reads instead of the fact tableCorrect
   • BCluster the fact table on the columns the dashboard's filters useCorrect
   • CReduce the dashboard's refresh frequency, so fewer queries run
   • DRestrict the dashboard to a shorter date range than users currently see
   • EMove the dashboard to a larger warehouse, so each scan finishes sooner
   ✓ Correct answer: A, B

   The constraint is that the output must not change, which rules out anything that shows users less. Aggregate tables preserve the figures while replacing a six terabyte scan with a small read, and clustering on the filtered columns lets skipping exclude most files for the queries that must still touch the detail. Both change how the answer is produced rather than what the answer is, which is exactly what the constraint permits.

   Why the other options are wrong

   • CLess frequent refresh means users see staler figures, which is a visible change. It is a legitimate trade and not one available here.
   • DA shorter range removes data users currently see, which the constraint rules out. It would reduce cost by reducing the deliverable.
   • EA larger warehouse completes the same scan faster at a higher rate, so cost is broadly unchanged. It buys latency rather than efficiency.
8. Question 8Ensuring Data Security and Compliance

   A compliance requirement states that personal data must not be readable by administrators who do not need it. What is the practical implication?

   • APrivileged roles need review and separation, since broad administrative rights read everythingCorrect
   • BAdministrators must be removed, since their role is incompatible with the requirement
   • CColumn masks are sufficient, since they apply uniformly to every principal
   • DEncryption at rest satisfies it, since administrators do not hold the keys
   ✓ Correct answer: A

   Broad administrative privileges typically confer the ability to grant oneself access or to read data directly, so a requirement of this kind is really a requirement about how those privileges are scoped, who holds them, and how their use is reviewed. The practical measures are separating platform administration from data access where the model allows, keeping the privileged group small, using time-bounded elevation for specific tasks, and reviewing audit records of privileged reads. Masks help and depend on the same privileged roles not being exempted.

   Why the other options are wrong

   • BSomeone must administer the platform, so removing the role is not available. The requirement constrains how it is held rather than whether.
   • CA mask applies according to its own logic, which frequently exempts privileged groups, and it can be altered by those able to alter it. Sufficiency cannot be assumed.
   • DEncryption at rest protects against access to the underlying storage rather than against a query by a privileged principal. It addresses a different threat.
9. Question 9Data Governance

   A team asks whether their reference data, such as country and currency codes, needs governance treatment. What is the argument that it does?

   • AMany datasets join to it, so an error or a change propagates widelyCorrect
   • BIt is large, so its storage and maintenance costs justify oversight
   • CIt changes frequently, so its history must be preserved for audit
   • DIt contains personal data, so access must be restricted
   ✓ Correct answer: A

   Reference data is tiny and touches almost everything, so a wrong code, a duplicated row or an unannounced change to a value propagates into many downstream results at once and is hard to trace afterwards. That blast radius, rather than size or sensitivity, is why it deserves an owner, documented meanings, change notification and quality checks. Teams often overlook it precisely because it looks trivial next to the fact tables.

   Why the other options are wrong

   • BReference data is small, so cost is negligible and cannot be the argument. Its importance is disproportionate to its size.
   • CIt changes rarely, which is part of why changes are surprising when they happen. Frequency is not the driver.
   • DCountry and currency codes are not personal data, so confidentiality is not the concern. Correctness and stability are.
10. Question 10Debugging and Deploying

    A query fails immediately with a message that a column cannot be resolved. What kind of failure is this?

    • AAn analysis failure, raised while the plan is built and before any data is readCorrect
    • BA runtime failure, raised when a task encounters a row lacking the column
    • CA permission failure, since an unresolvable column implies no access to it
    • DA resource failure, since resolution requires reading the table's metadata
    ✓ Correct answer: A

    Analysis resolves names against the catalog before execution begins, so an unresolvable column fails immediately, costs nothing, and points at a name that does not exist in the referenced object. The usual causes are a typo, a stale expectation of the schema after a producer's change, or the query pointing at a different environment's table than intended. The fact that no data was read is itself diagnostic, since it distinguishes this from failures that occur mid-run.

    Why the other options are wrong

    • BRows do not individually carry schemas, since the schema belongs to the table and is known before execution. There is no per-row resolution.
    • CInsufficient access produces a permission error naming the object, not an unresolvable column. The messages are distinct.
    • DReading catalog metadata is trivial and its failure would report differently. Resolution failed on the name rather than on resources.

Who this Databricks Certified Data Engineer Professional practice exam is for

This practice set is for anyone preparing for the Databricks Certified Data Engineer Professional exam at the advanced level - from first-time candidates building a foundation to experienced Data practitioners doing a final review before test day. If you learn best by working through realistic questions and reading why each answer is right or wrong, it is built for you.

How to use this Databricks Certified Data Engineer Professional practice exam

1. Start with the free sample questions above to gauge your current baseline.
2. Read the full explanation on every question, including why each wrong option is wrong.
3. Track your weak domains and focus your study where you are losing the most marks.
4. Once you are scoring consistently well, take a timed, full-length mock exam.
5. Use your readiness score to decide when you are ready to book the real Databricks Certified Data Engineer Professional exam.

Related Data resources

• Databricks Certified Data Engineer Professional study guideKey concepts
• Data practice examsAll Data
• Certification pathWhere this fits
• Certification exam guides & tipsBlog
• Plans & pricingFree & paid
• How these questions are written and reviewedMethodology
• Report a problem with a questionCorrections
• Databricks Certified Generative AI Engineer Associate practice examRelated
• Databricks Certified Machine Learning Associate practice examRelated
• MongoDB Associate Developer practice examRelated

Databricks Certified Data Engineer Professional practice exam FAQ