New Scheduled Job Never Ran? Why, and How to Catch the First Miss
Contents
A new scheduled job that never runs usually wasn't scheduled where you think: it was registered in another environment, the process that runs the scheduler wasn't deployed, it's disabled by default, its zone puts the first run later than expected, or its expression never matches a real date. None of these produce an error, and a heartbeat monitor that creates itself from the job's first ping can't catch them either, because there is no first ping. To hear about a first run that never happens, the monitor has to exist before the job is due.
This guide applies to crontab, systemd timers, Kubernetes CronJobs, and framework schedulers such as Hangfire, Quartz.NET, Celery beat, and Laravel, checked November 16, 2026. For jobs that ran before and then stopped, see cron job not running.
Why a First Run Is Different#
A job that worked yesterday and failed today leaves a trail: yesterday's log line, a last-run time, a monitor that went quiet. A job that never ran has no history to compare with. Nobody is watching for its output yet, the dashboard has no "last run" to look stale, and the team that shipped it assumes it works because the deploy succeeded.
So the useful question is not "why did it stop?" but "did the scheduler ever know about it, in this environment, enabled, at a time that exists?" Work through the causes below in that order.
1. It Was Registered in Another Environment#
The registration code ran, just not here:
- An environment guard.
if (env.IsProduction()), Laravel's->environments(['production']), or a feature flag that's off in the environment you're checking, or on only in staging. - The wrong storage or database. A Hangfire or Quartz.NET job registered against a staging connection string, a different SQL schema, or a different Redis prefix exists, but only where nobody runs it.
- A crontab on the wrong host. Installed on the build machine, a single instance of an autoscaled group that was later replaced, or the wrong user's crontab (
crontab -las root shows root's, not the deploy user's). - A database schedule that wasn't migrated. django-celery-beat keeps schedules in database tables, so a periodic task created through staging's Django admin doesn't exist in production.
Check from the running system, not from the code: list what the scheduler actually holds in that environment. crontab -l -u deploy, systemctl list-timers --all, kubectl get cronjobs -A, the Hangfire dashboard's Recurring Jobs page, php artisan schedule:list, or celery -A proj inspect registered for tasks the workers know.
2. The Scheduler Process Isn't Running#
Registering a job and running a scheduler are separate, and in several frameworks the scheduler is a process you have to deploy yourself:
| Scheduler | What has to be running |
|---|---|
| Laravel | A cron entry running php artisan schedule:run every minute, or php artisan schedule:work |
| Celery | A beat process (celery -A proj beat), separate from the workers |
| Hangfire | A process with AddHangfireServer() using the same storage |
| Quartz.NET | A started scheduler: scheduler.Start(), or AddQuartzHostedService() with AddQuartz |
| systemd | The timer started, not just enabled: systemctl enable --now job.timer |
| crontab | The cron daemon itself, which minimal container images don't include |
A new service is the classic case. The job is registered in a new worker, the worker's Helm chart has a Deployment for the API but none for the beat process, and nothing ever sends the task. Or a new container image runs a crontab with no cron daemon inside it; cron in Docker covers that. Celery beat not running and Laravel schedule not running go through the framework-specific checks.
3. It's Disabled by Default#
Several schedulers let a job exist in a paused state, and templates copied from elsewhere often carry it:
- Kubernetes:
suspend: truein the CronJob spec, sometimes set by a values file so a new job ships dark. - systemd: a timer installed and enabled, but not started until the next boot;
systemctl list-timers --allshows it with no next run. - django-celery-beat: a
PeriodicTaskrow withenabledunchecked. - Quartz.NET: a trigger that's paused, or a trigger whose
StartAtis in the future orEndAtin the past. - Feature flags around the job's body: the scheduler runs it, and the first line returns early. That one does run, but does nothing.
4. The First Run Is Later Than You Think#
A job scheduled 0 9 * * * and deployed at 10:00 runs tomorrow, not today. Add a zone mismatch and the first run moves further: Hangfire reads cron in UTC by default, a Kubernetes CronJob without timeZone uses the controller's zone, and Quartz.NET triggers default to the server's local zone. A job someone checks at 09:30 New York time on launch day may not be due until 09:00 UTC the next morning, or it may have run at 04:00 New York time while nobody watched. Why your cron monitor alerts an hour early or late lists where each scheduler takes its zone.
Weekly and monthly jobs make this worse. A 0 6 1 * * job deployed on the 2nd has its first run four weeks later, and if that run fails silently, the job has been broken for a month before anyone could have noticed.
5. The Schedule Never Matches#
Some expressions are valid and never fire:
- Impossible dates:
0 0 30 2 *is February 30. Hangfire's ownCron.Never()is0 0 31 2 *, built on the same idea.0 0 31 4,6,9,11 *is a 31st in months that have 30 days. - Both day fields restricted: in Vixie-style cron,
0 9 1-7 * 1runs on the 1st through 7th or any Monday; in Cronos (Hangfire) and systemd, only on a Monday within the 1st to 7th. A schedule that relies on one reading can run far more or far less than intended. - Fields in the wrong order: Celery's
crontab()takes positional arguments as minute, hour, day of week, day of month, month, not in cron's order, and a six-field Quartz expression with seconds, rewritten by hand for a five-field crontab, is easy to shift by one field.
Print the next few run times before deploying: systemd-analyze calendar --iterations=5 'Mon *-*-01..07 09:00' for systemd, the Hangfire dashboard's next execution, or a cron expression library's next-occurrences function in a test. A heartbeat monitor can't help here: if the expression never matches, there's no expected time to alert on. Cron expressions covers the field rules.
Why Self-Registering Monitors Miss a First Run#
Many heartbeat setups, CronRadar's included, let the first ping create the monitor: send schedule=0 2 * * * with the first report, and the monitor appears with that schedule. That's convenient for jobs that already run, and it means a monitor deleted by accident comes back on the next run.
It also means that until the first ping arrives, there's no monitor. A job that never runs never pings, so no monitor is created, so nothing expects it and nothing alerts. Every cause above lands in that blind spot. The job looks unmonitored in the dashboard, if anyone checks, and otherwise looks like nothing at all.
Create the Monitor Before the First Run#
A monitor created ahead of the job knows the schedule before any report arrives. In CronRadar, a monitor created from the dashboard, through the API, or by a framework integration's sync starts pending, with a first expected time from its schedule. If nothing arrives by then plus the grace period, CronRadar sends a NeverExecuted alert, "Your job has not checked in," and repeats it at most once every 24 hours while the job stays silent. When the first report arrives, the monitor leaves pending and is monitored like any other job.
Three ways to get there:
- Framework discovery. The Hangfire, Quartz.NET, Celery, and Laravel integrations read the scheduler's own registry and declare every job and its schedule, so a new recurring job gets a monitor when the process that holds the registry starts with the integration installed, before the job's first run. Discovery runs inside that process, though: if the process was never deployed (cause 2), nothing is declared. The Celery integration reads
app.conf.beat_scheduleand doesn't read django-celery-beat's database schedules, and Hangfire discovery covers recurring jobs, not one-timeEnqueueorSchedulejobs. - The dashboard, for a one-off job: create the monitor with its key, schedule, and grace period, then deploy the job reporting to that key.
- A sync call from the deploy pipeline, for crontab, systemd, or Kubernetes jobs that live in your repository. Declaring jobs from CI means the monitor exists even when the host or cluster never runs the job:
curl --fail-with-body --silent --show-error \
--user "$CRONRADAR_API_KEY:" \
--header "Content-Type: application/json" \
--data '{
"source": "infra-crontabs",
"version": "2026.11.16",
"monitors": [
{
"key": "monthly-invoices",
"name": "Monthly invoices",
"schedule": "0 6 1 * *",
"gracePeriod": 1800
}
]
}' \
"https://cron.life/api/v1/sync"Without a mode, sync is an upsert: it creates or updates these keys and leaves other monitors alone. Use the application and key for the environment the job runs in, so a staging deploy can't create production monitors. Check the response's errors array for a rejected schedule.
The job itself then reports to the same key over HTTP or with a base SDK for Python, Node.js, PHP, or .NET. After the first run, missed runs alert the usual way: after the expected time plus grace, the monitor goes from warning to critical. A fail report alerts immediately.
A Launch Checklist for New Scheduled Jobs#
- Confirm the scheduler holds the job in the target environment, using that scheduler's list command, not the code.
- Confirm the scheduler process runs there: the beat process, the Hangfire server,
schedule:runin cron, the started timer, the cron daemon. - Confirm it's enabled: no
suspend: true, paused trigger, disabled row, or early-returning flag. - Print the next three run times in the scheduler's zone and convert the first to your own clock.
- Create the monitor first, through discovery, the dashboard, or a sync call, and check it shows
pendingwith the expected first run. - Trigger one run by hand where the scheduler allows it (
kubectl create job --from=cronjob/..., Hangfire's Trigger now,systemctl start job.service), to test the job itself. That doesn't test the schedule, which is why step 5 matters. - Watch the first scheduled run. For a monthly job, note the date somewhere the team will see it.
Testing cron jobs covers testing the job's logic, and a scheduled job inventory keeps track of what should be running where.
Frequently Asked Questions#
Why didn't my new cron job run?#
Check, in order, that the scheduler in this environment actually holds the job, that the scheduler process is running, that the job isn't suspended or disabled, that its first run time has passed in the scheduler's time zone, and that the expression can match a real date. Each of these fails silently.
Can a heartbeat monitor detect a job that never ran?#
Only if the monitor exists before the first run. A monitor created by the job's first ping doesn't exist until that ping, so it can't alert on a job that never pings. Create it ahead from the dashboard, the API, or a framework integration, and it alerts when the first expected run plus grace passes with no check-in.
What is a NeverExecuted alert?#
It's the CronRadar alert for a monitor that was created ahead of time and never received its first report. CronRadar sends it after the first expected time plus the grace period, and repeats it at most once every 24 hours while the job stays silent.
How do I test a scheduled job before its first scheduled run?#
Trigger it by hand where the scheduler supports it, which tests the job, its environment, and its permissions. Separately, print the expression's next run times in the scheduler's zone. A manual trigger doesn't prove the schedule, so keep a monitor in place for the first real run.
Why does my job show as pending in CronRadar?#
The monitor exists but hasn't received its first report yet. That's expected before the first scheduled run. If the first expected time plus grace has passed and it's still pending, CronRadar sends a NeverExecuted alert, and the causes above are where to look.
Put this guide to work
Know when the next run is missing
Connect one scheduled job, confirm a real completion, then verify the alert destination. Keep your existing scheduler in charge of running the work.