CertLumen

Free study guide · Databricks

How to pass the Databricks Certified Data Engineer Associate

What the exam covers, how to plan your study, and how to read its questions. From the CertLumen course for this exam, kept up to date with the official exam guide.

Questions
45
Time
90 minutes
Passing score
Not published by Databricks; this kit targets ≥ 80% on unseen mocks
Exam fee
USD 200 (plus applicable taxes)
Valid for
2 years (renew by taking the current exam or the 25-question renewal exam)
Delivery
Online proctored or test center

What the exam covers

Databricks Intelligence Platform6%
Data Ingestion and Loading21%
Data Transformation and Modeling22%
Working with Lakeflow Jobs16%
Implementing CI/CD10%
Troubleshooting, Monitoring, and Optimization10%
Governance and Security15%

A study plan that works

The default path for engineers with some Spark or SQL experience and up to about six months on Databricks. It covers all 41 lessons and 12 labs in order, with a domain drill after each module and daily flashcards. Mock Exam 1 on day 20 is a diagnostic, Mock Exams 2–3 measure progress, and Mock Exam 4 plus weak-area review closes it out. Day 30 is a light day, so you sit the exam on day 31. The heaviest sections (d3 22%, d2 21%, d4 16%, d7 15%) get the most days. Plan on about 1.5–2 hours a day.

DayFocusTime
1Kick-off: exam map, lakehouse and Spark basics100 min
2DataFrames and Spark SQL110 min
3Delta Lake and Structured Streaming120 min
4Platform architecture and Unity Catalog90 min
5Compute, cost models and the workspace110 min
6Ingestion patterns and COPY INTO100 min
7Auto Loader deep dive110 min
8Lakeflow Connect, JDBC and REST110 min
9Semi-structured data and choosing a method120 min
10Ingestion review day100 min
11Medallion cleaning and joins110 min
12Columns, deduplication and aggregations120 min
13Tuning parameters and Gold objects110 min
14Declarative pipelines and data quality120 min
15Transformation review day100 min
16Lakeflow Jobs fundamentals and control flow110 min
17Triggers and orchestration choices120 min
18Jobs drill and Git folders110 min
19Bundles and the Databricks CLI120 min
20Mock Exam 1 (diagnostic)120 min
21Monitoring jobs and the Spark UI110 min
22Liquid clustering, predictive optimization and failures120 min
23Managed vs external tables and privileges120 min
24Row filters, column masks and ABAC120 min
25Lineage, auditing and governance review110 min
26Mock Exam 2120 min
27Weak-area remediation110 min
28Mock Exam 3120 min
29Mock Exam 4 and final weak-area review120 min
30Light day: cheat sheet and rest60 min

Exam strategy

How the exam works

The Databricks Certified Data Engineer Associate exam checks whether you can use the Databricks Data Intelligence Platform for foundational data engineering: ingesting, transforming, orchestrating, deploying, troubleshooting and governing data. Every item is single-answer multiple choice, mostly short scenarios asking for the best option under a stated constraint. Knowing that a feature exists isn't enough; you have to know when it's the right choice.

FactDetail (verified on the exam page, exam guide and certification FAQ)
Scored questions45 multiple-choice questions
Unscored itemsMay be included to gather statistics. They aren't marked and don't affect your score, and extra time is built in for them.
Time limit90 minutes, about 2 minutes per question
FeeUSD 200 plus applicable taxes
DeliveryOnline proctored or at a test center. You register on Webassessor, and Kryterion delivers the exam.
Test aidsNone allowed: no documentation, notes, or second screen
LanguagesEnglish, Japanese, Portuguese (BR) and Korean, per the exam page
PrerequisitesNone required. Training and about six months of hands-on Databricks experience are highly recommended.
Passing scoreNot published. Databricks says it can change.
Validity2 years. Renew by passing the current live exam, or the 25-question renewal exam, which opens 2 months before your credential expires.
Unscored items look like any other item

You can't tell which items are unscored, so treat every question as if it counts. If a question seems to be outside the outline, answer it quickly with your best guess and move on. It may be one of the unscored items.

Section weights: where the points are

The weights tell you where to spend study time. Four sections carry 74% of the score: Ingestion, Transformation, Lakeflow Jobs and Governance. The question counts below are estimates from the published weights. Databricks doesn't publish per-section counts, and individual exam forms vary.

SectionWeight≈ QuestionsKit moduleHighest-yield topics
1. Databricks Intelligence Platform6%3d1 (+ d0)Delta Lake + Unity Catalog as the foundation, compute selection, serverless limits, cost models
2. Data Ingestion and Loading21%9d2Auto Loader options and schema evolution, COPY INTO idempotency, Lakeflow Connect managed vs standard, method selection, JSON/VARIANT
3. Data Transformation and Modeling22%10d3 (+ d0)Joins and unions, dedup, aggregations, tuning configs, Gold objects, declarative pipelines, expectations
4. Working with Lakeflow Jobs16%7d4Run if conditions, If/else and For each tasks, retries, task values, scheduled/file arrival/table update triggers
5. Implementing CI/CD10%4–5d5Git folder workflow, bundle variables, targets and modes, databricks bundle CLI
6. Troubleshooting, Monitoring, and Optimization10%4–5d6Run history baselines, Spark UI skew/shuffle/spill, liquid clustering, predictive optimization, OOM and library conflicts
7. Governance and Security15%7d7Managed vs external tables, GRANT/REVOKE and the privilege hierarchy, row filters, column masks, ABAC
Total100%45
Where experienced engineers lose points

Spark veterans usually do well on Section 3 and lose points on Sections 2, 4 and 5, which test newer products: Lakeflow Connect managed connectors, table update triggers, For each tasks, Run if conditions, bundle variables and targets. Budget study time by weight and by unfamiliarity.

How to use this kit

  1. Learn. Read the lesson, answer its self-checks, and write down any key point you would have missed.
  2. Lab. Do the lab on Databricks Free Edition. Some exam details only stick once you've seen them happen, like Auto Loader failing once on a new column or COPY INTO loading 0 rows on a re-run.
  3. Drill. After each module, take its domain drill untimed. Read every explanation, including the notes on the options you rejected. The distractors teach as much as the answer.
  4. Flashcards. Review in short daily sessions. Mark the cards you miss and repeat them until you get them right two days in a row.
  5. Mocks. Take the four mock exams (45 questions, 90 minutes each) under exam conditions. Never take them open-book.
  6. Review loop. Keep an error log with four columns: topic, why you missed it (knowledge gap, misread constraint, or trap), the correct rule, and where the rule lives in the kit. Re-read that section and retest similar questions 48 hours later.
Don't re-take a mock to feel better

Your score on a repeated mock measures memory, not readiness. Count only first attempts toward the readiness criteria, and use repeat attempts just to review explanations.

Readiness criteria

  • ≥ 80% on two mock exams you hadn't seen before, each taken timed in one sitting.
  • ≥ 70% in every domain on those mocks. One weak domain carrying 15–22% of the weight can sink an otherwise good attempt.
  • You finish a mock in ≤ 75 minutes and still have time for a review pass.
  • Without notes, you can rebuild these cheat-sheet tables: Auto Loader vs COPY INTO, Run if conditions, Gold objects, UC privileges, and Spark UI symptom → fix.
  • You've done every lab at least once and can explain what each lab proved.
Why 80%?

Databricks doesn't publish the passing score, and community reports usually put it around 70%. Aiming for 80% on unseen mocks leaves a margin for a harder exam form, unfamiliar wording and exam-day nerves.

Time management

You have 90 minutes for 45 scored items plus any unscored ones, or roughly 2 minutes per question. Recall questions take 30–60 seconds, which saves time for long scenario and code questions. Use three passes.

  1. First pass (≈ 55–60 min). Answer everything you can within about 90 seconds. If you're stuck between two options, pick the better one, flag the question, and move on. Never leave a question blank.
  2. Second pass (≈ 15–20 min). Go back to the flagged questions. Re-read the stem's constraint words before re-reading the options.
  3. Final check (≈ 5 min). Make sure nothing is unanswered. Change an answer only for a concrete reason, such as a constraint you missed, and never on a vague feeling.
CheckpointTarget elapsed time
Question 15≤ 25 min
Question 30≤ 50 min
Question 45≤ 70 min, then flagged questions only
A blank answer always scores zero

An unanswered question earns nothing. When time is short, answer every remaining question first, then go back to the flagged ones.

Reading scenario questions

A typical item gives a few sentences of context, some of it irrelevant, and then asks for the best solution. One or two constraint words usually decide the answer. Read the question in this order:

  1. Read the last sentence (the actual ask) first.
  2. Find the constraint words: cost, overhead, latency, governance, privileges, idempotency.
  3. Predict the answer before you look at the options.
  4. Eliminate every option that breaks any constraint, then pick from what's left.
Constraint wordingWhat it usually rewards
"least operational overhead", "minimal maintenance"Managed, serverless, declarative options: Lakeflow Connect managed connectors, Lakeflow Spark Declarative Pipelines, serverless compute, predictive optimization, CLUSTER BY AUTO
"most cost-effective"Jobs compute or serverless jobs instead of all-purpose clusters, availableNow batches instead of always-on streams, autoscaling with auto-termination, spot workers for fault-tolerant batch
"incrementally", "only new files"Auto Loader or COPY INTO, which both track processed files, and streaming tables
"near real-time", "low latency"Structured Streaming with a processing-time or continuous trigger, continuous pipelines or jobs. Not an hourly schedule.
"governed", "in Unity Catalog"UC managed tables, volumes instead of DBFS, external locations with storage credentials, connectors that land data in UC
"minimum privileges", "least privilege"The smallest set of grants at the lowest level that works, such as USE CATALOG + USE SCHEMA + SELECT. Never ALL PRIVILEGES or ownership.
"idempotent", "safe to re-run"COPY INTO, Auto Loader checkpoints, MERGE instead of INSERT
"schema changes frequently"Auto Loader schema evolution (addNewColumns or rescue), mergeSchema, the VARIANT type
"same code across dev/test/prod"Declarative Automation Bundles with variables and target overrides
"as soon as data arrives"Data-driven triggers (file arrival or table update) instead of cron schedules

Elimination tactics

Words that point to the answer

Phrases in a question that usually point to one answer. The course has the full list.

When the question saysThink of
reliable rollback after a bad ingest, audit trail, single source of truth for AI and BIDelta Lake ACID transactions and time travel, governed by Unity Catalog
many analysts running ad hoc SQL concurrently, fast startup, cost-awareServerless SQL warehouse (autoscaling)
scheduled production ETL at the lowest costServerless jobs compute or jobs compute (job cluster), not all-purpose
workload needs the RDD API, R, init scripts or arbitrary Spark configsClassic compute in dedicated access mode
several users share one cluster with Unity Catalog fine-grained access controlStandard access mode (formerly shared)
query a PostgreSQL or Snowflake database without copying the dataLakehouse Federation (connection + foreign catalog)
share live tables with a partner organization, recipient may not use DatabricksDelta Sharing (open sharing protocol)
who read or changed a table last weekAudit logs: the system.access.audit system table
which downstream dashboards break if this column changesUnity Catalog data lineage
incrementally load new files from cloud storage with schema evolutionAuto Loader (cloudFiles)

Revise from the cheat sheet

The course's cheat sheet has a page for each of these:

  • Delta Lake commands and defaults
  • Structured Streaming essentials
  • Compute selection matrix
  • Auto Loader options
  • COPY INTO options
  • Ingestion decision matrix
  • Spark DataFrame API ↔ SQL equivalents
  • Joins and set operations
  • Aggregations and deduplication
  • Tuning configs and defaults
  • Gold layer objects compared
  • Declarative pipeline syntax and expectations
  • Lakeflow Jobs: tasks, Run if, triggers
  • Bundle databricks.yml skeleton and CLI commands
  • Git folder operations
  • Spark UI: symptom → cause → fix
  • Liquid clustering and predictive optimization
  • Unity Catalog privileges and hierarchy
  • Row filters, column masks and ABAC
  • Managed vs external tables and volumes

Practise with the real exam's mix

395 exam-style questions, 4 timed practice exams, flashcards and an AI tutor.

See the course