CKAD Application Design and Build Practice Question
You need to run a batch job that processes 100 items. The job should be considered complete when all items are processed successfully. You want to run up to 10 pods concurrently. Which job configuration is correct?
⚠ Common exam trap
Watch out — candidates often confuse the roles of `.spec.completions` and `.spec.parallelism`, where candidates often swap the values (e.g., setting completions to the concurrency limit) or omit completions entirely, not realizing that both fields are needed to define a parallel Job with a fixed total number of completions.
Answer choices
Why each option matters
Answer the question above first, then reveal the full breakdown to understand why each option is right or wrong.
Correct answer & explanation
✓
.spec.completions: 100, .spec.parallelism: 10
It sets `.spec.completions` to 100 (the total number of items to process) and `.spec.parallelism` to 10 (the maximum number of pods running concurrently). This ensures the Job runs pods in parallel up to the specified limit until all 100 completions are achieved, matching the requirement of processing 100 items with up to 10 concurrent pods.
Answer analysis
Option-by-option breakdown
For each option: why learners choose it and why it is or isn't the right answer here.
- ✗
.spec.completions: 10, .spec.parallelism: 100
Why it's wrong here
Setting .spec.completions to 10 and .spec.parallelism to 100 defines a Job that terminates as soon as 10 Pods complete successfully. Even though up to 100 Pods may run concurrently, the Job’s desired completion count is only 10, so it would stop after processing just 10 items, not the required 100. The extra parallelism is wasted because completions, not parallelism, determines the success threshold.
- ✗
.spec.backoffLimit: 100, .spec.parallelism: 10
Why it's wrong here
The .spec.backoffLimit field controls how many times the Job controller retries a failed Pod before marking the Job as failed; it has no bearing on how many Pods must succeed. With no .spec.completions specified, the Job defaults to completions=1, meaning only a single successful Pod is required. Therefore this configuration would complete after one item is processed, leaving 99 items undone.
- ✗
.spec.completions: 100, .spec.parallelism: 1
Why it's wrong here
A parallelism of 1 forces the Job controller to run Pods strictly sequentially: the next Pod is not created until the current one finishes, regardless of how many completions are desired. While .spec.completions=100 correctly requires 100 successful Pods, the Job will execute them one at a time, so it cannot satisfy a requirement to process items with a concurrency factor of 10. This configuration is functionally correct in total count but violates the concurrency constraint.
- ✓
.spec.completions: 100, .spec.parallelism: 10
Why this is correct
This is the correct configuration because .spec.completions specifies the exact number of Pods that must finish successfully (100), and .spec.parallelism limits how many of those Pods can run simultaneously (10). The Job controller creates Pods in waves, using the parallelism value as an upper bound on concurrent execution, while tracking cumulative completions until the target of 100 is reached. This matches the requirement of processing 100 items with up to 10 Pods running at once.
Go deeper
Related to this question
About these practice questions
One of 160 original CKAD practice questions on Courseiva, each with a full explanation and wrong-answer analysis — not exam dumps or protected exam content. Learn why practice questions differ from exam dumps →
JA
Written by Johnson Ajibi, MSc IT Security
Senior Network & Security Engineer · founder of Courseiva
This CKAD practice question is part of Courseiva's free CNCF certification practice question bank. Courseiva provides original exam-style practice questions with explanations, topic-based practice, mock exams, readiness tracking, and study analytics to help learners prepare for the CKAD exam.