The Databricks Certified Associate Developer for Apache Spark (commonly called the Spark Developer exam) measures your ability to implement DataFrame API and Spark SQL workloads in PySpark — all code on the exam is in Python. Platform features such as Unity Catalog are out of scope — what's tested is deep Apache Spark API knowledge. The largest section, building applications with the DataFrame/DataSet API, is 30% of the exam, so reading the API reference and hands-on practice are the keys to passing.
| Item | Details |
|---|---|
| Exam name | Databricks Certified Associate Developer for Apache Spark |
| Questions | 45 |
| Duration | 90 minutes (about 2 minutes per question) |
| Passing score | Not published (set through statistical analysis, subject to change) |
| Exam fee | $200 (excl. tax) |
| Language | English only |
| Code language | Python (all code on the exam is in Python) |
| Validity | 2 years |
| Code question share | Not published |
Because the exam is English-only, every question, answer choice, and code snippet appears in English. Learning the technical terms in English directly will boost your reading speed.
| Section | Weight | Approx. questions |
|---|---|---|
| 1. Apache Spark Architecture and Components | 20% | ~9 |
| 2. Using Spark SQL | 20% | ~9 |
| 3. Developing Apache Spark DataFrame/DataSet API Applications | 30% | ~13-14 |
| 4. Troubleshooting and Tuning Apache Spark DataFrame API Applications | 10% | ~4-5 |
| 5. Structured Streaming | 10% | ~4-5 |
| 6. Using Spark Connect to deploy applications | 5% | ~2 |
| 7. Using Pandas API on Apache Spark | 5% | ~2 |
Tests whether you understand Spark internals. Conceptual multiple-choice questions dominate this section — not code.
The highest-weighted section. Tests whether you precisely understand the arguments, return values, and behavior of the main PySpark DataFrame API methods.
df.select("col1", "col2") selects columns; df.withColumn("new_col", expr) adds or transforms a column. The difference: select returns only the listed columns, while withColumn returns all original columns plus the new one.df.filter(col("age") > 30) and df.where("age > 30") are equivalent. To combine conditions, use & (AND) and | (OR), wrapping each condition in parentheses.df.groupBy("dept").agg(count("*"), avg("salary")) applies multiple aggregations at once. Know the difference vs. agg-less groupBy().count().df1.join(df2, "key", "inner")'s third argument specifies the join type. The 7 types are inner / left / right / outer / cross / semi / anti. Semi join returns no columns from the right table; anti join returns only non-matching rows.Window.partitionBy("dept").orderBy("salary") defines a window, then apply row_number(), rank(), dense_rank(), lag(), lead(). row_number assigns sequential numbers even on ties; rank assigns the same number to ties and leaves gaps; dense_rank assigns the same number to ties with no gaps.spark.sql("SELECT ...") returns a DataFrame. Use createOrReplaceTempView("view_name") to expose a DataFrame to SQL.COALESCE, NULLIF, CASE WHEN, CAST, and date functions (date_add, datediff, date_format).spark.read.format("csv").option("header", "true").option("inferSchema", "true") reads CSV. Know how to read and write JSON, Parquet, ORC, and Avro, and the characteristics of each format.StructType and StructField let you specify a schema explicitly to avoid the overhead of inferSchema (which scans the entire dataset).df.write.partitionBy("year", "month") partitions data into a directory structure. Watch out for the small-files problem caused by over-partitioning (e.g., partitioning by high-cardinality columns).append (add to existing data), overwrite (replace existing data), error/errorifexists (default — errors if the table exists), and ignore (does nothing if the table exists). Four modes total.Lambda operations on arrays (ArrayType) and maps (MapType). They are not named in the official objectives, but knowing them alongside Section 3 topics such as exploding arrays makes questions on array data easier to work through.
transform(array_col, x -> x * 2) doubles every element.filter(array_col, x -> x > 0) keeps only positive values.exists(array_col, x -> x == "target")spark.readStream.format("rate") or format("socket") to create test streams.append (emits only new rows; for non-aggregating streams), complete (emits the full result every batch; for aggregating streams), and update (emits only changed rows). Three modes total.withWatermark("timestamp", "10 minutes") sets the tolerance for late data. Data arriving past the watermark is dropped.trigger(processingTime="5 seconds") (sets the micro-batch interval) and trigger(availableNow=True) (processes all available data and then stops).broadcast_var = sc.broadcast(lookup_dict) distributes read-only data to every Executor. Used for large dictionaries and lookup tables.acc = sc.accumulator(0) creates a distributed counter. If you update an accumulator inside a Transformation, the value can be incremented multiple times when an Action re-runs the Transformation.df.cache() (memory only) vs. df.persist(StorageLevel.MEMORY_AND_DISK). Caching pays off when the same DataFrame is referenced multiple times.According to the official page, all code on the Spark Developer exam is shown in Python. The comparison below is for reference when choosing a language for real-world work.
| Aspect | PySpark | Scala |
|---|---|---|
| Learning resources | Abundant (official docs, Qiita, YouTube) | Limited |
| Real-world usage | Used by 80%+ of Databricks users | Under 20% |
| Type safety | Dynamically typed (runtime errors) | Statically typed (compile-time errors) |
| Performance | DataFrame API matches Scala | Faster than PySpark for RDD operations |
| On the exam | The exam language (all code is Python) | Not used |
Databricks
Question 1
When inner-joining a 100GB DataFrame (df_large) with a 50MB DataFrame (df_small) in PySpark, which approach gives the best performance?
Correct answer: B
The 50MB DataFrame is small enough that explicitly hinting a broadcast hash join with broadcast() yields the best performance. A broadcast hash join copies df_small to every Executor and joins without a shuffle, sharply reducing network traffic. Option A might let Catalyst/AQE choose a broadcast join automatically, but the default spark.sql.autoBroadcastJoinThreshold is 10MB, so a 50MB table is outside the auto-broadcast range — an explicit broadcast hint is the reliable choice. Option C's repartition triggers a full shuffle on both tables, moving 100GB of data, which is inefficient. Option D's cache doesn't change the join strategy, so the performance impact is limited.
Is the code on the Spark Developer exam in Python or Scala?
According to the official page, all code on the Spark Developer exam is shown in Python. You cannot opt for Scala, so focus your study on PySpark. Official docs, Databricks Academy, and community resources are overwhelmingly Python-based too, which works in your favor.
What share of the exam is code questions, and how should I prepare for them?
Databricks does not publish the share of code questions. According to the official page, all code is shown in Python. The largest section, Section 3 (building applications with the DataFrame/DataSet API, 30%), lists column and row manipulation, joins, aggregations, and UDFs among its objectives, and Structured Streaming readStream/writeStream is in scope too. Most questions ask about the execution result of a snippet, so you need to know the return types and behavior of PySpark APIs precisely. Studying by actually running code in Free Edition (the successor to Community Edition) is the most effective approach.
How does the Spark Developer exam compare in difficulty to Data Engineer Associate?
DEA covers the Databricks platform broadly but shallowly, while Spark Developer focuses on deep Spark / PySpark API knowledge. Platform features such as Unity Catalog and Lakeflow Jobs are not in scope — only pure Spark API knowledge is tested. Neither exam publishes its share of code questions, but on Spark Developer all code is shown in Python and the DataFrame/DataSet API section is 30% of the exam, so reading the API reference and hands-on practice are essential. The English-only format also raises the difficulty bar.
Related Databricks Certification Articles
Practice with certification-focused question sets
Try free questionsNicheeLab Editorial Team
NicheeLab editorial team focused on data engineering and cloud certification learning. Content is structured around practical study needs and official exam domains.
Databricks Certifications: All 8 Exams, Difficulty & Study Plan (2026)
Complete guide to all 8 Databricks certifications — Data Eng...
Databricks Exam Difficulty Ranking: 7 Certs Compared (2026)
Seven Databricks certifications ranked by difficulty, with s...
Databricks Study Guide: Fastest Pass Route & Time Estimates (2026)
How to pass Databricks certifications efficiently. Official ...
Databricks Data Engineer Associate: Complete Guide (2026)
Domain-by-domain breakdown of the Databricks Certified Data ...
Databricks Data Engineer Professional: Complete Guide (2026)
Tactics for the Databricks Certified Data Engineer Professio...