CKAD Application Design and Build Practice Question
A CronJob is configured with 'concurrencyPolicy: Forbid'. If a job from the previous schedule is still running when the next scheduled time arrives, what happens?
⚠ Common exam trap
Watch out — candidates often confuse 'skipped' with 'queued' or 'delayed' — the CronJob does not wait for the old Job to finish and then start the new one; it simply drops the missed run entirely, which is a key distinction tested in the CKAD exam.
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
✓
The new job is skipped until the old job completes
When `concurrencyPolicy: Forbid` is set on a CronJob, the CronJob controller will skip creating a new Job if the previous Job from the last schedule is still running. The new Job is effectively skipped (not queued) until the next scheduled time, preventing overlapping executions. This ensures that only one instance of the Job runs at a time.
Answer analysis
Option-by-option breakdown
For each option: why learners choose it and why it is or isn't the right answer here.
- ✗
The CronJob is suspended
Why it's wrong here
Suspending a CronJob disables all future scheduled runs entirely, which is a different mechanism from concurrencyPolicy. The spec.suspend field prevents the controller from creating any new Jobs regardless of whether an old Job is running. In contrast, concurrencyPolicy: Forbid only affects what happens when a scheduled time coincides with an active Job; the CronJob itself remains active and continues to evaluate future schedules.
- ✗
The new job starts immediately, and the old job is terminated
Why it's wrong here
This description actually matches the Replace concurrency policy, not Forbid. When Replace is set, a new scheduled run deletes the currently active Job and immediately creates a replacement Job, effectively terminating the old one. With Forbid, however, the old Job is left alone and allowed to finish; the new run is just skipped, so termination never happens as part of this policy.
- ✓
The new job is skipped until the old job completes
Why this is correct
With concurrencyPolicy: Forbid, the CronJob controller prevents overlapping executions by checking for any active Jobs from the same CronJob at each scheduled fire time. If one exists, the new run is not created—it is skipped entirely, and no subsequent catch-up occurs for that missed schedule. Once the active Job completes, the next regular schedule is processed normally, so the skip is permanent for that firing.
- ✗
Both jobs run concurrently
Why it's wrong here
This behavior is exactly what concurrencyPolicy: Allow does—it permits multiple Jobs from the same CronJob to run simultaneously, which Forbid explicitly forbids. Under Allow, each scheduled invocation creates a new Job even if previous ones are still running, leading to overlapping execution. Forbid instead enforces a strict no-overlap rule by skipping the new Job when the old one is active, so concurrent execution is never allowed.
About these practice questions
This CKAD question is part of Courseiva's 826-question bank — original exam-style content with full explanations and wrong-answer analysis, never real exam questions or exam dumps. 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.