CKAD Application Design and Build Practice Question
You have a CronJob that runs every 5 minutes. The previous job is still running when the next scheduled time arrives. You want the new job to be skipped if the previous one is still running. Which concurrencyPolicy should you set?
⚠ Common exam trap
Many candidates confuse 'Skip' with 'Forbid' because 'skip' sounds like it means 'do not start the new job,' but Kubernetes uses the term 'Forbid' for this behavior, and 'Skip' is not a valid concurrency policy value.
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
✓
Forbid
The `Forbid` concurrency policy in Kubernetes CronJobs ensures that if a previous job instance is still running when the next scheduled time arrives, the new job is skipped entirely. This prevents overlapping executions, which is exactly the requirement in the question.
Answer analysis
Option-by-option breakdown
For each option: why learners choose it and why it is or isn't the right answer here.
- ✗
Skip
Why it's wrong here
Skip is not a valid value for the CronJob field `concurrencyPolicy`, which only accepts `Allow`, `Forbid`, or `Replace`. If you attempt to set `concurrencyPolicy: Skip`, the Kubernetes API server will reject the manifest with a validation error before the CronJob is ever created, so this option cannot achieve the desired behavior. The intended 'skip an overlapping run' semantic is implemented by the `Forbid` policy, not by a literal policy named 'Skip'.
- ✗
Allow
Why it's wrong here
Allow is the default concurrency policy and explicitly permits multiple Job instances to overlap. If the previous Job is still running when the next scheduled time arrives, a new Job is created immediately, leading to concurrent executions that could cause race conditions, duplicate data processing, or resource contention. Choosing Allow directly contradicts the requirement to skip the new run when the previous one is active, making it an incorrect answer for this constraint.
- ✗
Replace
Why it's wrong here
Replace causes the CronJob controller to terminate the currently running Job instance and then create a new one at the next scheduled time. This is not the same as skipping: instead of leaving the in-progress work alone and missing the next run, it forcefully cancels the active Job and starts a fresh one, which can lose progress and is fundamentally different from the required behavior. Because the stem explicitly says the new Job must be skipped—not that the old one should be killed—Replace fails to satisfy the constraint.
- ✓
Forbid
Why this is correct
Setting `concurrencyPolicy: Forbid` on the CronJob ensures that if a previous Job instance is still actively running when the next scheduled time arrives, the new Job is simply skipped rather than queued or allowed to overlap. This directly satisfies the constraint in the stem that the new job must be skipped when the previous one is still executing, preventing concurrent runs without blocking future schedules.
Go deeper
Related to this question
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.