DBX-ASD Databricks Associate Developer for Apache Spark
- Vendor
- Databricks
- Level
- Associate
- Questions
- 45
- Time
- 90 min
- Domains
- 7
- In the bank
- 285
Practice 285 questionsTake a timed mock examDay-by-day study plan
Guides for this exam
- 8 Mistakes That Repeat Across Every Databricks Exam, and How to Spot Each One in the Question · 한국어
- DBX-ASD Study Guide: Ask Five Questions of Every Code Snippet Before You Read the Choices · 한국어
The exam at a glance
| Level | Associate |
|---|---|
| Questions | 45 |
| Time | 90 minutes (about 2 minutes per question) |
| Passing mark | Not published by the vendor |
Domains and weights
| Domain | Weight | Practice questions here |
|---|---|---|
| D1 · Apache Spark Architecture and Components | 20% | 57 |
| D2 · Using Spark SQL | 20% | 57 |
| D3 · Developing Apache Spark DataFrame/DataSet API Applications | 30% | 86 |
| D4 · Troubleshooting and Tuning Apache Spark DataFrame API Applications | 10% | 29 |
| D5 · Structured Streaming | 10% | 28 |
| D6 · Using Spark Connect to Deploy Applications | 5% | 14 |
| D7 · Using Pandas API on Spark | 5% | 14 |
D1 · Apache Spark Architecture and Components 20%
Architecture questions ask what Spark does when code runs: which jobs, stages and tasks appear, where memory goes, and what a session shares. Read the code for actions, shuffles and caching. Strong options follow Spark's execution model step by step; weaker ones assume work is reused or shared when it is not.
What to watch for
- Transformations are lazy; each action starts a job, and a shuffle splits a job into stages.
- Without cache(), a second action recomputes its lineage, though shuffle files can let the UI skip stages.
- Temporary views belong to one SparkSession; global temp views live in global_temp and are shared across sessions.
Tasks in the official exam guide (7)
- 1.1 Identify the advantages and challenges of implementing Spark
- 1.2 Identify the roles of core Spark components: cluster, driver, workers/executors, cores and memory
- 1.3 Describe Spark architecture: DataFrame and Dataset, SparkSession lifecycle, caching, storage levels, garbage collection
- 1.4 Explain the Spark execution hierarchy
- 1.5 Configure Spark partitioning, including shuffles and partitions
- 1.6 Describe execution patterns: actions, transformations and lazy evaluation
- 1.7 Identify features of Spark modules: Core, Spark SQL, DataFrames, pandas API on Spark, Structured Streaming, MLlib
D2 · Using Spark SQL 20%
Spark SQL questions give a query or a read/write call and ask what it returns or why it fails. Check the save mode, the data source options and how the schema is inferred. Strong options name the exact option or clause that produces the result; weaker ones rely on defaults that behave differently.
What to watch for
- Save modes differ on retry: append writes the rows again, overwrite replaces, ignore and errorifexists check first.
- Plain Parquet overwrite is not atomic; a failed job can leave the path empty or partial, while Delta keeps the old version.
- Reading files with SQL needs options such as header for CSV, otherwise columns are named _c0, _c1 and so on.
Tasks in the official exam guide (4)
- 2.1 Read and write DataFrames from data sources such as JDBC and files, including overwrite and partitioning by column
- 2.2 Run SQL directly on files (ORC, JSON, CSV, text, Delta) and understand save modes
- 2.3 Save data to persistent tables with sorting and partitioning for retrieval
- 2.4 Register DataFrames as temporary views and query them with SQL
D3 · Developing Apache Spark DataFrame/DataSet API Applications 30%
DataFrame API questions show a few lines of PySpark and ask for the result or the right method. Trace the rows through joins, groupings and nulls by hand. Strong options get the row count and join semantics exactly right; weaker ones treat NULL keys as equal or forget that a grouped count is a DataFrame.
What to watch for
- NULL never matches NULL in a join condition, so left_anti keeps rows with a NULL key.
- groupBy().count() returns a DataFrame; count() on it is an action that returns a number.
- sortWithinPartitions orders each output file without the shuffle of a global orderBy.
Tasks in the official exam guide (10)
- 3.1 Manipulate columns, rows and table structures: add, drop, split, rename, filter, explode arrays
- 3.2 Perform data deduplication and validation on DataFrames
- 3.3 Perform aggregations: count, approximate count distinct, mean, summary
- 3.4 Work with dates: Unix epoch to date string, extract date components
- 3.5 Combine DataFrames: inner, left, broadcast, multi-key and cross joins, union and union all
- 3.6 Manage input and output: write, overwrite and read DataFrames with schemas
- 3.7 Sort, iterate, print schema and convert between DataFrames and lists/sequences
- 3.8 Create and invoke user-defined functions with or without stateful operators, including StateStores
- 3.9 Describe variable types in Spark: broadcast variables and accumulators
- 3.10 Describe the purpose and implementation of broadcast joins
D4 · Troubleshooting and Tuning Apache Spark DataFrame API Applications 10%
Tuning questions describe a slow or failing stage and ask for the fix. Read the Spark UI clues: number of tasks, partition sizes, join strategy and where the error happens. Strong options change the one setting or step that matches the symptom; weaker ones add memory or partitions without addressing the cause.
What to watch for
- Adaptive Query Execution coalesces small shuffle partitions and can switch a sort-merge join to a broadcast join at runtime.
- coalesce reduces partitions without a shuffle; repartition shuffles to balance or increase them.
- Executor OOM in a shuffle stage with huge partitions calls for more shuffle partitions, not a larger driver.
Tasks in the official exam guide (3)
D5 · Structured Streaming 10%
Structured Streaming questions ask what a query does over time and after failures. The checkpoint, the watermark and the output mode decide most answers. Strong options keep state bounded and recovery exact; weaker ones use batch-only operations or unbounded state.
What to watch for
- Exactly-once needs a replayable source, a checkpoint and an idempotent or transactional sink.
- Without a watermark, dropDuplicates and aggregations keep state forever and it keeps growing.
- Sorting a stream is allowed only after an aggregation in complete output mode.
Tasks in the official exam guide (4)
- 5.1 Explain the Structured Streaming engine: programming model, micro-batches, exactly-once semantics, fault tolerance
- 5.2 Create and write streaming DataFrames and Datasets, with basic output modes and sinks
- 5.3 Perform basic operations on streams: selection, projection, window and aggregation
- 5.4 Perform streaming deduplication with and without a watermark
D6 · Using Spark Connect to Deploy Applications 5%
Deployment questions ask how a Spark application reaches a cluster: cluster managers, deploy modes and Spark Connect. The deciding detail is where the driver runs and what the client holds. Strong options separate the thin client from the server; weaker ones expect JVM or SparkContext access through Spark Connect.
What to watch for
- Spark Connect sends unresolved logical plans over gRPC and streams results back as Arrow batches.
- With Spark Connect the server can be upgraded on its own, and APIs that need the driver JVM such as sparkContext are not available.
- Spark runs on standalone, YARN and Kubernetes cluster managers.
Tasks in the official exam guide (2)
D7 · Using Pandas API on Spark 5%
Pandas API on Spark questions ask when pandas-style code scales and how pandas UDFs work. Check how data is split between workers and what each function receives. Strong options respect the size and shape rules of each API; weaker ones assume one group or one batch can be any size.
What to watch for
- pandas API on Spark keeps the pandas syntax but distributes the data, so one machine's memory is no longer the limit.
- Pandas UDFs exchange data with Arrow in batches, which is much faster than a row-at-a-time Python UDF.
- A Series to Series UDF must return the same length; applyInPandas loads a whole group into one task's memory.
Tasks in the official exam guide (2)
A study order that works
The 17-day study plan for DBX-ASD takes the domains in this order. Each day has a short reading, key terms and a quiz from the bank.
- Days 1–3: D1 · Apache Spark Architecture and Components
- Days 4–5: D2 · Using Spark SQL
- Days 6–10: D3 · Developing Apache Spark DataFrame/DataSet API Applications
- Days 11–12: D4 · Troubleshooting and Tuning Apache Spark DataFrame API Applications
- Days 13–14: D5 · Structured Streaming
- Day 15: D6 · Using Spark Connect to Deploy Applications
- Day 16: D7 · Using Pandas API on Spark
- Day 17: Final Review: Decision Cheat-Sheet Across the Seven Domains
Recent changes to these questions
- : 2 answer choice sets changed, 2 answer keys corrected, 2 explanations rewritten
- : 60 questions added
- : 2 answer choice sets changed, 2 answer keys corrected, 2 explanations rewritten
- : Exam added to the bank (225 questions added)
About these questions
Every question is original, written from the public exam guide and checked against the vendor's own documentation. None comes from a real exam. Each one has an explanation of why the answer is right and why the other options are wrong. How the questions are written.