Free
- Untimed practice across all seven domains
- Every question explained against the objective it tests
- Domains by name and official weight
Databricks · Associate Developer for Apache Spark
The DataFrame API is 30% of this exam.
Architecture is 20% and Spark SQL is another 20% — together they outweigh the domain everyone studies. Add troubleshooting, Structured Streaming, Spark Connect and the Pandas API and 70% of the form is something other than writing DataFrame transformations. 45 questions in 90 minutes across seven domains, against a pass mark Databricks doesn't publish.
- Weighted to the official seven-domain split, including Spark Connect and the Pandas API
- Architecture practised as its own domain, at the same weight the exam gives it
- Python throughout, the way the current exam is written
Free practice across all seven domains. No card required.
Associate Developer for Apache SparkApache Spark Architecture and ComponentsMedium
A notebook cell defines a DataFrame, applies three filters and a join, and finishes with `df.cache()`. The cell returns in under a second. What has Spark done?
Select one.
One choice only. Your earliest pick was dropped.
Where this question sits in the exam
Apache Spark Architecture and Components is 20% of the Associate Developer for Apache Spark exam. Our mocks use the same mix.
0 of 1 selected
An original item written against the Databricks certification page, last checked 18 September 2026. Not a real exam question.
How it's scored
The pass mark isn't just unpublished. It moves.
Databricks sets passing scores statistically and revises them as questions change. That's their stated reason for not printing one — so the figure you've seen quoted didn't come from them.
A readiness read still needs a line, so we use 80% weighted accuracy. It's ours, not theirs, and it's drawn that way: dashed where a published pass mark would be solid.
We set it high on purpose. Being too strict costs you a week of practice. Being too lenient costs you USD 200.
Associate Developer for Apache Spark45 questions · 90 min
Accuracy by domain, weighted as the exam weights them · assumed 80% — ours, not Databricks'
Architecture20%74%
Spark SQL20%71%
DataFrame API30%68%
Tuning10%Furthest behind54%
Streaming10%61%
Spark Connect5%81%
Pandas API5%77%
Troubleshooting and Tuning Apache Spark DataFrame API Applications is your lowest score. Developing Apache Spark DataFrame/DataSet API Applications is the bigger drag — a smaller gap, but on 30% of the form instead of 10%.
Recertifying here means the full current exam
The credential lasts two years. Databricks publishes a 25-question renewal exam for the Data Engineer Associate and none for this credential. Recertifying means sitting whatever version of the full exam is live then.
On a platform shipping this fast the guide will have moved. Features that did not exist when you certified are on the form, and topics you revised for may be gone.
What the questions look like
Code you read, and behaviour you have to know cold
Four snippets, one clause apart
DataFrame items hand you variations that differ in a single function call. Selecting a field through an array of structs is valid and returns something other than what you wanted, which is why reading the type in the stem matters more than recognising the function.
Execution model, not trivia
Architecture items ask what has actually happened by the time a cell returns. Lazy evaluation, what counts as an action, and where a shuffle comes from are 20% of the form on their own.
Two domains that barely appear
Spark Connect and the Pandas API are 5% each — around two questions apiece. Small enough to be tempting to skip, and large enough that skipping both costs you a tenth of the exam.
The loop
Practice, sit, review, repeat
Step 1 is free. Steps 2 to 4 need a subscription.
certs.acedify.com/apache-spark-developer-associate
Practice · untimed
MediumA notebook cell defines a DataFrame, applies three filters and a join, and finishes with `df.cache()`. The cell returns in under a second.
What has Spark done?
Executed the filters and join, and stored the result in memory
Executed the filters, but deferred the join until the data is needed
Nothing beyond building the plan — `cache()` marks the DataFrame, and no computation happens until an action runs
Executed everything, because `cache()` is an action
Filters, joins and `cache()` are transformations or markers. Nothing computes until an action asks for results, which is why the cell returns immediately. `cache()` is not an action. Domain: Apache Spark Architecture and Components.
Click a step to see it.
What you get back
No official line. So we show you ours.
Your readiness is a range, because it's an inference from the questions you've answered rather than a result you've earned. For a certification the outcome is binary, so the question is whether the whole range sits above the line.
The difference here is whose line it is. AWS publishes 720 and we measure you against their number. Databricks publishes nothing, so we measure you against ours — 80% weighted accuracy, set high on purpose, drawn dashed and labelled everywhere it appears.
Spark Connect and the Pandas API are 5% each. A zero in either costs you about two questions; a weak DataFrame domain costs you fourteen.
When the range stops narrowing and stops rising, more drilling isn't buying you anything, and that's worth knowing before you book.
If the real pass mark is below ours, the worst case is that you sat more practice than you needed. We'd rather make that mistake than the other one.
Associate Developer for Apache Spark · 4 mocks completed
Where you stand
Borderline
70–90
assumed 80% — ours, not Databricks'
Your range crosses our assumed line. On today's evidence it's a coin flip, and we'll say so.
Three states
Try the three states. We won't show you a percentage chance of passing — nobody can calculate one honestly without years of real outcomes to calibrate against.
What we don't do
We won't show you a percentage chance of passing. Nobody can calculate one honestly without years of real outcomes behind it.
What it actually tests
Seven domains, and the one you know is 30% of it
Everyone preparing for this exam practises DataFrame transformations, and that's the largest domain. It's also less than a third of the form. Architecture and Spark SQL are 20% each — 40% between them — and the remaining four domains add another 30%.
| Domain | Weight | What it covers |
|---|---|---|
| Apache Spark Architecture and Components | 20% · about 9 questions | Joint second-largest. Execution and deployment modes, the driver/executor/slot/task hierarchy, lazy evaluation, shuffling, broadcasting, fault tolerance and garbage collection. |
| Using Spark SQL | 20% · about 9 questions | Joint second-largest, and the domain people are surprised by. Spark SQL is weighted the same as architecture and two-thirds of the DataFrame API domain. |
| Developing Apache Spark DataFrame/DataSet API Applications | 30% · about 14 questions | The largest domain, and still less than a third of the exam. Selecting, filtering, adding columns, joins, aggregations and complex types. |
| Troubleshooting and Tuning Apache Spark DataFrame API Applications | 10% · about 5 questions | Reading what went wrong: skew, spill, partition counts and adaptive query execution. |
| Structured Streaming | 10% · about 5 questions | Streaming as a DataFrame: triggers, output modes, checkpointing and what makes a stream restartable. |
| Using Spark Connect to deploy applications | 5% · about 2 questions | Joint smallest — around two questions. The client/server split that decouples an application from the cluster. |
| Using Pandas API on Apache Spark | 5% · about 2 questions | Joint smallest. Pandas-style code executing on Spark, and where the two APIs behave differently. |
Domain weights are published on the Databricks certification page. Last checked 18 September 2026 against the /en/ page.
Architecture plus Spark SQL is 40% of the form — more than the DataFrame API domain on its own.
Exam facts
Null fields are omitted. We do not print TBA.
- Credential
- Databricks Certified Associate Developer for Apache Spark
- Level
- Associate
- Length
- 90 minutes
- Scored questions
- 45
- Unscored questions
- Present, count not published
- Question types
- Multiple choice
- Pass mark
- Not published
- Domains
- 7
- Fee
- USD 200 + local tax
- Test aids
- None
- Validity
- 2 years
- Retake wait
- 14 days between attempts, unlimited attempts, full fee each
- Recertification
- Full current exam — no renewal exam for this credential
Pricing
Practice free. Pay when you want to know where you stand.
Pro
- Timed mocks at 45 questions in 90 minutes
- Weighted accuracy across every mock you've sat
- Your readiness range, and how it moves
Everything on every exam, one subscription
One subscription covers the Databricks certifications, AWS, the Microsoft certifications, the Salesforce certifications, the Claude certifications, TOEFL, IELTS and the SAT.
The exam fee is separate and goes to Databricks. We're prep, not registration.
Start practising for freeFAQ
Associate Developer for Apache Spark questions
Find out which domain is furthest behind
Free practice across all seven domains, no card. The timed mocks and the readiness range are there when you want them.
Start practising for freeAlso available for the Data Engineer Associate, Data Engineer Professional and the rest of the Databricks track on the same subscription.