# Kubernetes CronJob Not Running? A Troubleshooting Checklist

By Dan Ochoa · Published 2026-11-16 · Updated 2026-11-16
Canonical: https://cronradar.com/blog/kubernetes-cronjob-not-running

> Fix a Kubernetes CronJob that does not run: suspend, startingDeadlineSeconds, too many missed start times, concurrencyPolicy, stuck Jobs, time zones, quotas.

**When a Kubernetes CronJob doesn't run, the failure sits at one of three levels: the CronJob controller never created a Job, the Job never got a running Pod, or the Pod ran and failed.** `kubectl get cronjob` and the CronJob's events tell you which level, and the Job's and Pod's events tell you why. Start at the top and work down; most causes leave a specific event behind, as long as you look within an hour.

This checklist covers `batch/v1` CronJobs on Kubernetes 1.27 and later, checked against the [CronJob](https://kubernetes.io/docs/concepts/workloads/controllers/cron-jobs/) and [Job](https://kubernetes.io/docs/concepts/workloads/controllers/job/) documentation on November 16, 2026. For metrics, Prometheus rules, and a full monitoring setup, see [Kubernetes CronJob monitoring](https://cronradar.com/blog/kubernetes-cronjob-monitoring).

## Find the Level That Failed

A CronJob is a template plus a schedule. The CronJob controller in kube-controller-manager creates a Job at each scheduled time, the Job controller creates Pods, and the kubelet runs the container. Each step can stop the run.

```bash
kubectl get cronjob nightly-report              # SUSPEND, ACTIVE, LAST SCHEDULE
kubectl describe cronjob nightly-report         # spec, active Jobs, recent events
kubectl events --for cronjob/nightly-report     # events recorded on the CronJob
kubectl get jobs --watch                        # Jobs as they are created and finish
```

| What you see                                         | Likely cause                                | Section |
| ---------------------------------------------------- | ------------------------------------------- | ------- |
| `SUSPEND` is `True`                                  | The CronJob is suspended                    | 1       |
| `MissSchedule` events, `LAST SCHEDULE` falls behind  | `startingDeadlineSeconds` too short         | 2       |
| `TooManyMissedTimes` warning                         | More than 100 missed start times            | 3       |
| `JobAlreadyActive` events, `ACTIVE` stays at 1       | `concurrencyPolicy: Forbid` and a stuck Job | 4, 5    |
| Runs start but never finish                          | `Replace` kills them, or the Job is stuck   | 4, 5    |
| It runs, but hours off                               | The schedule is read in another time zone   | 6       |
| No events at all, nothing scheduled anywhere         | Controller or clock problem                 | 7       |
| Job exists, no Pod, `FailedCreate` on the Job        | Quota, LimitRange, or admission policy      | 8       |
| Pod `Pending`, `ErrImagePull`, or `ImagePullBackOff` | Scheduling or image problem                 | 8       |
| Pod ran and failed                                   | The job itself; see its logs and exit code  | 9       |

Kubernetes events are kept for one hour by default (the kube-apiserver `--event-ttl` flag), so a 2 AM failure checked at 9 AM may have left nothing to read. To reproduce a run on demand, create a Job from the template:

```bash
kubectl create job nightly-report-manual --from=cronjob/nightly-report
```

That tests the template, image, and Pod, but not the schedule or the controller, so it can succeed while scheduled runs still don't happen.

## 1. The CronJob Is Suspended

`.spec.suspend: true` stops new runs. The docs are precise: suspended executions "remain scheduled, but the CronJob controller does not start the Jobs," and Jobs already started keep running ([schedule suspension](https://kubernetes.io/docs/concepts/workloads/controllers/cron-jobs/#schedule-suspension)). A CronJob suspended during an incident, by a Helm value, or by a GitOps overlay for a staging cluster stays quiet indefinitely, and nothing records that it's quiet.

```bash
kubectl get cronjobs -A -o custom-columns=\
NS:.metadata.namespace,NAME:.metadata.name,SUSPEND:.spec.suspend,LAST:.status.lastScheduleTime
kubectl patch cronjob nightly-report -p '{"spec":{"suspend":false}}'
```

Unsuspending has a side effect. Suspended executions count as missed Jobs, and when `suspend` goes from `true` to `false` on a CronJob without a starting deadline, "a Job for the most recent missed schedule is started immediately." Earlier missed schedules don't run. If an immediate run would be wrong, such as a billing job at noon, set `startingDeadlineSeconds` before unsuspending so the stale run is skipped.

If your deployment tool owns the manifest, a `kubectl patch` will be reverted on the next sync. Fix the value in the source.

## 2. startingDeadlineSeconds Is Too Short

`startingDeadlineSeconds` is how late a run may start. If the controller can't create the Job within that many seconds of its scheduled time, it skips that run and records a `MissSchedule` event; future runs are still scheduled ([starting deadline](https://kubernetes.io/docs/concepts/workloads/controllers/cron-jobs/#starting-deadline)). Unset means no deadline.

A short deadline turns any delay into a skipped run: a controller restart, leader election during an upgrade, or a previous run still active under `Forbid`. The docs add a hard floor: below 10 seconds the CronJob "may not be scheduled," because the controller checks every 10 seconds.

```bash
kubectl get cronjob nightly-report -o jsonpath='{.spec.startingDeadlineSeconds}{"\n"}'
kubectl events --for cronjob/nightly-report | grep -i miss
```

Pick a deadline you'd accept as late, not the tightest value that usually works: for a nightly job, 600 or 3600 seconds is reasonable. The deadline is still useful, because without one a run delayed by hours starts whenever the controller gets to it.

## 3. "Too Many Missed Start Times"

At each check, the controller counts the schedules it missed since the last scheduled time. If there are more than 100, it records a `TooManyMissedTimes` warning:

```text
too many missed start times. Set or decrease .spec.startingDeadlineSeconds or check clock skew
```

On current Kubernetes, this does not stop the CronJob. The controller "still starts a Job for the most recent missed schedule," and the earlier ones are never started ([CronJob limitations](https://kubernetes.io/docs/concepts/workloads/controllers/cron-jobs/#cron-job-limitations)). Advice to delete and recreate the CronJob comes from the controller that Kubernetes replaced in 1.21.

You get here when a frequent schedule meets a long gap: a `* * * * *` CronJob that was suspended for two hours, a controller down overnight, or a clock that jumped. With `startingDeadlineSeconds` set, the controller counts only misses inside that window: at 200 seconds, a one-minute schedule can miss at most three. So the fix the message suggests is the right one, and it also stops a long outage from producing a surprise catch-up run.

## 4. concurrencyPolicy Holds or Kills Runs

`concurrencyPolicy` decides what happens when a run is due and the previous Job hasn't finished ([concurrency policy](https://kubernetes.io/docs/concepts/workloads/controllers/cron-jobs/#concurrency-policy)):

| Policy            | When the previous Job is still active        | What it looks like                     |
| ----------------- | -------------------------------------------- | -------------------------------------- |
| `Allow` (default) | Starts another Job alongside it              | Overlapping runs, rarely "not running" |
| `Forbid`          | Skips the new run; `JobAlreadyActive` event  | Runs stop while one Job hangs          |
| `Replace`         | Deletes the running Job and starts a new one | Runs start but never finish            |

`Forbid` is the usual cause of "it ran once and then stopped." One Job hangs, every later run is held, and `ACTIVE` stays at 1. When that Job finally finishes, `startingDeadlineSeconds` is still applied, so a held run may start late or be skipped. Under `Forbid`, a held run also counts as missed toward the 100-schedule check.

`Replace` hides the opposite problem. A job that takes 70 minutes on an hourly schedule is killed every hour and never completes, while `kubectl get jobs` shows a fresh Job each time. If the work can't finish within one interval, either the interval or the job has to change.

```bash
kubectl get cronjob nightly-report -o jsonpath='{.spec.concurrencyPolicy}{"  "}{.status.active}{"\n"}'
```

## 5. A Job Is Stuck Active

A Job stays active while it has Pods that haven't succeeded and it hasn't hit a limit. Find the active Job and look at its Pods:

```bash
kubectl get jobs --sort-by=.metadata.creationTimestamp
kubectl describe job nightly-report-29384750
kubectl get pods -l batch.kubernetes.io/job-name=nightly-report-29384750
kubectl logs -l batch.kubernetes.io/job-name=nightly-report-29384750 --tail=50
```

The usual reasons:

- **The process never exits.** A hung network call, a lock wait, or a worker that keeps a non-daemon thread alive. The Pod shows `Running` for hours.
- **The Pod never starts.** `Pending` with a `FailedScheduling` event, or an image that can't be pulled (section 8). The Job stays active the whole time.
- **Retries in progress.** With `restartPolicy: OnFailure`, the container restarts in place and the Pod's `RESTARTS` count climbs; with `Never`, the Job creates new Pods with a growing back-off delay until `backoffLimit` (default 6) is reached.

Give every scheduled Job an upper bound with `activeDeadlineSeconds` in the `jobTemplate.spec`. Once a Job reaches it, its running Pods are terminated and the Job fails with reason `DeadlineExceeded`; it takes precedence over `backoffLimit` ([Job termination](https://kubernetes.io/docs/concepts/workloads/controllers/job/#job-termination-and-cleanup)). Set it on the Job spec, not the Pod spec, which has a field with the same name. [Kubernetes CronJob failure handling](https://cronradar.com/blog/kubernetes-cronjob-failure-handling) covers retries and deadlines in depth.

## 6. It Runs at the Wrong Time

Without `.spec.timeZone`, kube-controller-manager reads the schedule in its own local time zone, which on a managed cluster you usually can't see. `0 2 * * *` might mean 02:00 UTC when you meant 02:00 in Chicago, which looks like a job that "didn't run" when you checked at 03:00 local time.

```bash
kubectl get cronjob nightly-report -o jsonpath='{.spec.schedule}{"  "}{.spec.timeZone}{"\n"}'
kubectl get cronjob nightly-report -o jsonpath='{.status.lastScheduleTime}{"\n"}'
```

`lastScheduleTime` is an RFC 3339 timestamp in UTC, so compare it with the hour you expected in UTC. Set `.spec.timeZone` to an IANA name such as `America/Chicago` (stable since 1.27). `CRON_TZ=` or `TZ=` inside `.spec.schedule` fails validation on new CronJobs. Daylight saving time can also skip a run or double it on transition nights; [cron and daylight saving time](https://cronradar.com/blog/cron-daylight-saving-time) traces what the controller does.

## 7. The Controller or the Clock

If no CronJob in the cluster is creating Jobs, the problem is the controller, not your spec. On a self-managed cluster, check that kube-controller-manager is running and holds its leader lease:

```bash
kubectl -n kube-system get pods -l component=kube-controller-manager
kubectl -n kube-system get lease kube-controller-manager -o jsonpath='{.spec.holderIdentity}{"\n"}'
kubectl -n kube-system logs -l component=kube-controller-manager --tail=200 | grep -i cronjob
```

The `component=kube-controller-manager` label is what kubeadm sets on its static Pod; other installers differ, and on managed services the control plane isn't visible at all, so check the provider's control-plane logs or status page.

Clock skew shows up in the "too many missed start times" message for a reason: the controller compares scheduled times with its own clock. A control-plane node whose clock jumped forward sees many missed schedules at once; one that runs behind creates Jobs late. Check that time synchronization is running on control-plane nodes.

Two documented quirks are not bugs to chase. Scheduling is "approximate": in some circumstances "two Jobs might be created, or no Job might be created," which is why the docs ask for idempotent Jobs. And edits to a CronJob apply only to Jobs created afterward; a running Job keeps the old template.

## 8. The Job Can't Create a Running Pod

If a Job exists but its Pods don't, read the Job's events:

```bash
kubectl describe job nightly-report-29384750 | sed -n '/Events:/,$p'
kubectl get events --field-selector involvedObject.name=nightly-report-29384750
```

A `FailedCreate` event with a message like `pods "..." is forbidden: exceeded quota` means a ResourceQuota in the namespace has no room. A LimitRange or an admission webhook (Pod Security admission, Kyverno, Gatekeeper) can reject the Pod the same way, with its reason in the message. The CronJob controller can also record `FailedCreate` on the CronJob when it can't create the Job itself, for example because a quota on Job objects or an admission policy rejects it.

If the Pod exists but doesn't run, read the Pod's events:

| Pod status / event                 | Meaning                                             |
| ---------------------------------- | --------------------------------------------------- |
| `Pending`, `FailedScheduling`      | No node fits: CPU, memory, taints, node selectors   |
| `ErrImagePull`, `ImagePullBackOff` | Wrong tag, missing registry credentials, rate limit |
| `CreateContainerConfigError`       | A referenced Secret or ConfigMap is missing         |
| `OOMKilled` in the last state      | The container exceeded its memory limit             |

Image problems are common after a CI change: a tag that was never pushed, an `imagePullSecrets` entry that exists in one namespace but not this one, or a public registry's pull rate limit hit at midnight when every CronJob in the cluster starts at once.

## 9. The Pod Ran and Failed

If a Pod ran, the CronJob did its part. Read the logs, including the previous container attempt when `restartPolicy: OnFailure` restarted it, and the exit code:

```bash
kubectl logs nightly-report-29384750-x7k2p --previous
kubectl get pod nightly-report-29384750-x7k2p \
  -o jsonpath='{range .status.containerStatuses[*]}{.name}{" "}{.state.terminated.exitCode}{" "}{.lastState.terminated.exitCode}{" "}{.lastState.terminated.reason}{"\n"}{end}'
```

With `failedJobsHistoryLimit` at its default of 1, only the most recent failed Job is kept, so the evidence for older failures is deleted with the Job. Raise it, or ship logs off the cluster.

## Get Told When a CronJob Doesn't Run

Every section above starts after someone noticed. Kubernetes records what happened as status and short-lived events; it doesn't notify anyone, and when the controller or the cluster is the thing that broke, there's nothing inside it to raise the alarm. An external check that knows when each run is due catches all nine causes the same way: no report arrives.

There's no CronRadar integration for Kubernetes and no discovery of CronJobs; each CronJob reports over HTTP from its container, with a monitor key and schedule per job. The container reports start, runs the job, reports complete or fail, and exits with the job's own code:

```yaml
command:
  - /bin/sh
  - -c
  - |
    report() {
      event=$1
      shift
      curl --fail --silent --show-error --max-time 5 --output /dev/null \
        --request POST --get --user "$CRONRADAR_API_KEY:" \
        --data-urlencode "schedule=0 2 * * *" \
        --data-urlencode "run_id=$RUN_ID" \
        "$@" "https://cron.life/api/v1/ping/nightly-report/$event" || true
    }

    report start
    /app/nightly-report
    rc=$?
    if [ "$rc" -eq 0 ]; then
      report complete
    else
      report fail --data-urlencode "message=nightly-report exited with code $rc"
    fi
    exit "$rc"
```

`CRONRADAR_API_KEY` comes from a Secret and `RUN_ID` from the Pod's `batch.kubernetes.io/job-name` label through the downward API; the [monitoring guide](https://cronradar.com/blog/kubernetes-cronjob-monitoring) has the full manifest. Because every report carries the schedule, the first run creates the monitor. After the expected time plus the grace period with no report, the monitor goes from `warning` to `critical` and alerts by email, Slack, webhook, Discord, or PagerDuty. A `fail` report alerts immediately, and a start with no finish, such as a Pod killed by `activeDeadlineSeconds`, is flagged as stuck.

CronRadar evaluates schedules in the application's time zone, an IANA name set in the application's settings (UTC when unset). Set it to the CronJob's `timeZone`, or write both in UTC. One limit to know: a monitor that creates itself from its first report can't alert on a CronJob that has never run. For a new CronJob, create the monitor first in the dashboard so it starts `pending` and alerts if the first run never checks in.

## Frequently Asked Questions

### Why is my Kubernetes CronJob not creating Jobs?

Check `kubectl get cronjob` for `SUSPEND` set to `True`, then the CronJob's events for `MissSchedule`, `JobAlreadyActive`, or `TooManyMissedTimes`. A suspended CronJob, a `Forbid` policy behind a stuck Job, and a short `startingDeadlineSeconds` cover most cases. If no CronJob in the cluster is creating Jobs, look at kube-controller-manager.

### What does "too many missed start times" mean?

The controller found more than 100 missed schedules since the last scheduled time, usually after a suspension, an outage, or a clock jump on a frequent schedule. Current Kubernetes still starts a Job for the most recent missed schedule and skips the rest. Setting `startingDeadlineSeconds` limits the count to misses inside that window.

### Why did my CronJob run immediately after I unsuspended it?

Suspended executions count as missed. Without a starting deadline, unsuspending starts a Job for the most recent missed schedule right away. Set `startingDeadlineSeconds` before unsuspending if that run would be stale.

### How do I test a CronJob without waiting for the schedule?

`kubectl create job test-run --from=cronjob/nightly-report` creates a Job from the CronJob's template immediately. It tests the image, the Pod spec, and your code, but not the schedule, the time zone, or the controller.

### Why does my CronJob run at the wrong hour?

Without `.spec.timeZone`, the schedule is read in kube-controller-manager's local time zone. Set `timeZone` to an IANA name such as `Europe/Berlin`. `CRON_TZ` or `TZ` inside the schedule is rejected by validation.
