CKAD Application Design and Build Practice Question
A CronJob is configured with 'concurrencyPolicy: Forbid'. What happens if the scheduled time arrives while the previous job is still running?
⚠ Common exam trap
Watch out — candidates often confuse `concurrencyPolicy: Forbid` with `concurrencyPolicy: Replace`, which would terminate the running job; or they assume that a skipped job will be retried immediately, but Kubernetes does not automatically retry skipped executions under the `Forbid` policy.
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 next scheduled time
When `concurrencyPolicy: Forbid` is set on a CronJob, Kubernetes ensures that no new Job is created if the previous Job is still running. The CronJob controller checks the status of the most recent Job; if it has not completed, the scheduled execution is skipped entirely, and the next run occurs at the next scheduled time. This prevents overlapping executions, which is critical for workloads that must not run concurrently.
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 new job is skipped until the next scheduled time
Why this is correct
With concurrencyPolicy set to Forbid, the CronJob controller checks whether any Job created from this CronJob is currently active. If a previous Job is still running at the scheduled time, the controller simply skips the newly triggered execution. The missed run is not queued or retried; it is permanently lost until the next schedule fires.
- ✗
The new job starts immediately, running concurrently
Why it's wrong here
Allowing immediate concurrent execution is the behavior of concurrencyPolicy Allow, not Forbid. Forbid explicitly prevents overlapping runs by inspecting the active Job list before creating a new Job, so a second Job will never be launched while the first is still running. This policy is key when jobs interact with shared resources that cannot handle simultaneous processes.
- ✗
The running job is terminated and the new job starts
Why it's wrong here
Terminating the running Job and replacing it with a new one describes concurrencyPolicy Replace, which sends a termination signal to the active pod and then creates a fresh Job. Forbid takes no destructive action against the existing Job; it leaves it untouched and merely declines to create the scheduled Job. This distinction matters because Replace can cause data inconsistencies if the job is not idempotent.
- ✗
The CronJob enters an error state
Why it's wrong here
A CronJob does not transition to an error state when a run is skipped due to Forbid; the skip is a normal, expected event recorded in the controller's status and events. The CronJob remains in its ready state and continues to evaluate future schedules. Only misconfigured CronJobs with invalid schedule strings or object references would generate error conditions in the controller.
Go deeper
Related to this question
About these practice questions
One of 826 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.