Databricks Data Engineer Associate: Exam Guide and 74-Question Practice Test

1. The current exam blueprint

The exam checks foundational data engineering work on the Databricks platform. It is not only about PySpark. It covers ingestion, transformation, Lakeflow Jobs, deployment with code, Spark troubleshooting, and governance.

These are Databricks’ domain weights. They do not tell you exactly how many questions you will see from each domain on your own form. The timed simulation below uses a proportional 45-question mix as practice.

What changed from older material

Many study sites still use names and topics from before May 2026. These are the changes that matter for reading the exam and the docs.

2. Practice test: 74 original questions with explanations

I wrote every question here myself from the published objectives. They are not Databricks content, they are not recalled from a live exam, and they do not reuse the sample questions in Databricks’ guide. Each answer comes with the reason and a short takeaway.

3. Study guide by domain

Each section lists what the outline asks for, in plain words, then the things people tend to get wrong. The domains are in the order of the official outline.

Domain 1: Databricks Intelligence Platform (6%)

The outline asks you to know the core pieces (architecture, Delta Lake, Unity Catalog) and to choose compute by workload, including each option’s limits and cost model.

• Delta Lake gives ACID transactions, a transaction log, time travel, and RESTORE. Unity Catalog adds access control, lineage, and auditing on top.
• Serverless compute is usually the first option for supported notebooks, jobs, and pipelines.
• A SQL warehouse is the compute for SQL analytics, dashboards, and BI with many users at once.
• Classic compute is for cases serverless does not cover, for example RDD APIs or the R language.
• Read cost as a model, not a number. Compare how each option bills, then use current regional pricing.

Domain 2: Data Ingestion and Loading (21%)

You need to pick the right ingestion tool from the source, the volume, the frequency, and the governance needs.

A basic Auto Loader read and write looks like this. Replace the paths and the table name with your own.

source = (spark.readStream
    .format("cloudFiles")
    .option("cloudFiles.format", "json")
    .option("cloudFiles.schemaLocation", schema_path)
    .load(source_path))

(source.writeStream
    .option("checkpointLocation", checkpoint_path)
    .trigger(availableNow=True)
    .toTable("main.bronze.orders"))

• The availableNow trigger reads everything new, then stops. That is how you run Auto Loader as a scheduled batch job.
• JSON, CSV, and XML columns are inferred as strings by default. Cast them in the silver layer.
• With the default addNewColumns mode, a new field makes the stream stop with UnknownFieldException. Restart it and it carries on with the new schema.
• A rescued data column keeps values that did not fit the schema, so you can inspect them later.
• Auto Loader does not promise any file order. Write transformations that cope with late and out-of-order files.
• For nested JSON, parse to a known structure, then use explode when each array element needs its own row.

Domain 3: Data Transformation and Modeling (22%)

This is the biggest domain, so most of your practice time belongs here. The outline covers cleaning, combining, reshaping, deduplicating, aggregating, tuning, gold objects, and quality checks.

from pyspark.sql import functions as F

silver = (spark.table("main.bronze.orders")
    .withColumn("quantity", F.expr("try_cast(quantity as int)"))
    .withColumn("order_date", F.to_date("order_date", "yyyy-MM-dd"))
    .filter(F.col("order_id").isNotNull())
    .dropDuplicates(["order_id"]))

silver.write.mode("overwrite").saveAsTable("main.silver.orders")

• Joins: inner, left, broadcast, multiple keys, and cross. A cross join multiplies row counts, so estimate the result first.
• Union: in SQL, UNION removes duplicates and UNION ALL keeps them. In the DataFrame API, union() behaves like UNION ALL. Use unionByName when column order differs.
• Columns and rows: add, drop, rename, split a string with split, filter, and turn arrays into rows with explode.
• Deduplication: decide the business key first. For change data, order by a sequence column and use the CDC features instead of a blind dropDuplicates.
• Aggregates: count, approx_count_distinct, mean, and summary. Use the approximate version only when an estimate is acceptable.
• Tuning: spark.sql.shuffle.partitions sets partitions after DataFrame shuffles. spark.default.parallelism mostly affects RDD operations. spark.sql.autoBroadcastJoinThreshold is the size limit for automatic broadcast joins. Change one setting at a time and re-measure.
• Gold objects: a view stores a query. A materialized view stores a maintained result. A streaming table processes appended data incrementally. A plain table is just stored data.

Quality checks in a Lakeflow pipeline are written as expectations. This SQL drops rows with no order ID and only records a warning for non-positive quantities.

CREATE OR REFRESH STREAMING TABLE silver_orders (
  CONSTRAINT valid_order_id EXPECT (order_id IS NOT NULL) ON VIOLATION DROP ROW,
  CONSTRAINT positive_quantity EXPECT (quantity > 0)
)
AS SELECT * FROM STREAM(bronze_orders);

An expectation with no action only warns. DROP ROW removes the bad rows. FAIL UPDATE stops the pipeline update.

Domain 4: Working with Lakeflow Jobs (16%)

Think of a job as a graph of tasks, not a list of scripts.

• Task types: notebook, SQL query, dashboard, and pipeline tasks.
• Dependencies: a task starts after the tasks it depends on succeed. Independent tasks run in parallel.
• Control flow: retries for transient failures, If/else for branching on a true or false value, and For each to run a nested task over an array.
• Triggers: scheduled for clock-driven work, file arrival when new files land in a monitored location, and table update when a source table changes.
• Choosing: use a time trigger when the deadline is a time. Use a data trigger when the event is the data itself. A data trigger avoids empty runs.
• Recovery: a repair run reruns failed and downstream tasks and keeps the results of tasks that already succeeded.
• Timeouts: a status of Timed Out means the run passed the timeout set on that task.

Domain 5: Implementing CI/CD (10%)

Git folders handle day-to-day work: create and switch branches, commit, push, and open pull requests. Declarative Automation Bundles handle deployment: the job, its code, and its settings live in files, and one project is promoted through dev, test, and prod.

bundle:
  name: orders_etl

variables:
  catalog:
    description: Catalog that receives the tables
    default: dev_catalog

targets:
  dev:
    default: true
    workspace:
      host: https://dev-workspace.example.com
  prod:
    variables:
      catalog: prod_catalog
    workspace:
      host: https://prod-workspace.example.com

databricks bundle validate
databricks bundle deploy -t dev
databricks bundle run -t dev orders_job

The target name and the job key must exist in your own bundle. Validate checks the configuration. It does not prove the workload will run well.

• Use variables and target overrides for differences between environments, not separate copies of the project.
• A variable can take its value from an environment variable named BUNDLE_VAR_ followed by the variable name. CI can then supply a value per environment, including values from a secret store.
• Never put a password in databricks.yml or in notebook source.
• Unattended deployments should use a service principal with only the permissions needed, not a person’s token.

Domain 6: Troubleshooting, Monitoring, and Optimization (10%)

Diagnose before you resize. A bigger cluster fixes some problems and hides others.

• Run history: compare today’s run time against earlier runs and find the task that changed.
• Job status and task graph: read statuses, then look at the graph to find the upstream task that blocked the rest.
• Skew: most tasks finish quickly, a few take far longer, and the maximum shuffle read is much larger than the median.
• Spill: intermediate data moved to disk because memory ran short. Look at the operation and the partition sizes before adding memory.
• Driver out of memory: usually caused by pulling a large result to the driver with collect(). Keep large data distributed.
• Cluster startup failures: read the cluster event log and driver logs. Library conflicts and init scripts are common causes.
• Liquid Clustering: lets you change clustering keys as query patterns change. Predictive optimization runs maintenance automatically on eligible Unity Catalog managed tables.

Adaptive Query Execution can split skewed partitions in joins. It does not rescue a skewed aggregation. For a hot key in a groupBy, salt the key, aggregate, then combine the partial results.

from pyspark.sql import functions as F

buckets = 16
partial = (events
    .withColumn("salt", (F.rand() * buckets).cast("int"))
    .groupBy("device_id", "salt")
    .agg(F.sum("bytes").alias("partial_bytes")))

total = (partial
    .groupBy("device_id")
    .agg(F.sum("partial_bytes").alias("total_bytes")))

Domain 7: Governance and Security (15%)

Unity Catalog sorts objects into a hierarchy: metastore, catalog, schema, then tables, views, volumes, and functions. Privileges flow down that hierarchy.

GRANT USE CATALOG ON CATALOG main TO `analysts`;
GRANT USE SCHEMA ON SCHEMA main.sales TO `analysts`;
GRANT SELECT ON TABLE main.sales.orders TO `analysts`;

REVOKE SELECT ON TABLE main.sales.orders FROM `analysts`;

• Reading a table needs SELECT, plus USE CATALOG and USE SCHEMA on the parents.
• MODIFY allows inserts, updates, and deletes. Do not grant it where SELECT is enough.
• A privilege granted on a schema covers the tables in it, including tables created later.
• The outline names GRANT, REVOKE, and DENY, for users, groups, and service principals. Grant to groups and change membership as people move.
• Managed tables are managed by Unity Catalog, which also handles storage and lifecycle. They are the default for most new tables. External tables point at data whose lifecycle you manage elsewhere.
• You can convert between the two. ALTER TABLE ... SET MANAGED converts an external table to managed, and UNSET MANAGED rolls it back inside a limited window that Databricks documents as 14 days. Check the docs for the runtime you use.
• A row filter hides rows. A column mask changes what a column shows. Both use SQL functions.
• ABAC applies row filters and column masks from governed tags, so one policy can cover many tables, including ones tagged later.

CREATE FUNCTION main.security.mask_national_id(national_id STRING)
RETURN CASE WHEN is_account_group_member('hr_admins') THEN national_id ELSE '***' END;

ALTER TABLE main.hr.employees
ALTER COLUMN national_id SET MASK main.security.mask_national_id;

4. Twelve traps and how to read a question

Traps that cost marks

How to read a question

1. Find the objective being tested. Most questions map to one line of the outline.
2. Underline the constraint: lowest cost, least operational work, event-driven, governed, safe to rerun.
3. Remove options that break the constraint before you compare the rest.
4. Watch for options that are real features used in the wrong place.
5. If two options look right, choose the one that needs the least custom code and fits the platform feature built for the job.
6. Mark a question and move on if you are stuck for more than two minutes.

5. A 21-day study plan

This plan assumes 60 to 90 focused minutes on most days. If you already work in Databricks, shorten the first week and let the practice bank show you the gaps. If Spark or Unity Catalog is new, spend longer in the official courses before the timed simulation.

6. Ten hands-on tasks

Databricks says the best preparation includes practice on the platform, and suggests tasks small enough for Databricks Free Edition. Not every feature is available in Free Edition, so check what your workspace includes. These ten tasks map to the outline.

1. Create a catalog, a schema, and a managed table. Then create an external table and compare how each behaves when dropped.
2. Load a folder of CSV files with COPY INTO, add a new file, and run it again.
3. Read a folder of JSON files with Auto Loader. Add a file with a new column and watch what the stream does.
4. Build bronze, silver, and gold tables from one source, with a quality rule that drops bad rows.
5. Join a large table to a small one, read the plan, and try a broadcast. Re-measure.
6. Build a job with three tasks, a retry, an If/else, and a file arrival trigger.
7. Break a task on purpose, then fix it with a repair run.
8. Create a bundle with a dev and a prod target and one variable. Validate and deploy to dev.
9. Create a skewed dataset, find the slow task in the Spark UI, and fix it with salting.
10. Grant a group read access, apply a column mask, and test with a user inside and a user outside the group.

7. Registration, retakes, and results

Before you schedule

1. Download the exam guide that applies to your exam date, and check the page again two weeks before.
2. Do the training listed in the guide: Data Ingestion with Lakeflow Connect, Deploy Workloads with Lakeflow Jobs, DevOps Essentials for Data Engineering, Build Data Pipelines with Apache Spark Declarative Pipelines, and Getting started with Governance.
3. Practice on the platform. Reading definitions will not prepare you for troubleshooting questions.
4. For online proctoring, read Kryterion’s requirements and run the system check. A work computer with a firewall can get your session suspended.
5. Check the registration page for fees, languages, and test center locations in your region.

8. Official resources

The exam guide is the source of truth for the blueprint. Documentation changes faster than the guide, so check the date on any page you study from.

Related guides on Ultimate Info Guide

9. Frequently asked questions