Twice a year, in many countries, the clocks change. In spring an hour is skipped, and in autumn an hour is lived twice. A cron schedule is written against the clock, so a job set for 02:30 meets a day when there is no 02:30, and another day when there are two. Whether the job then runs late, does not run at all, or runs twice depends on which scheduler you use, and most people do not find out until the night it happens.
This guide explains what happens in each case, and why the answer is not the same everywhere. It draws on the crontab(5) and cron(8) manual pages of the cronie project, on GitHub's documentation of scheduled workflows, on the Kubernetes documentation of CronJobs, and on the IANA time zone database, all linked at the end. It also uses the work on the cron expression explainer on this site, which lists the runs of a schedule that fall into a skipped or repeated hour.
The short answer: avoid scheduling at the hours when clocks change, schedule in UTC where you can, and make every job safe to run twice or to miss once.
Why a clock change is a problem for a schedule
A cron expression has no time zone of its own. It is read against a clock, and which clock depends on the scheduler: the local time of the server for a classic cron daemon, UTC for many cloud services, and a zone you can choose in others. When that clock jumps, the schedule meets times that do not exist or times that exist twice.
The two cases are different. In spring the clock jumps forward, so a stretch of local time is skipped. A job set inside that stretch has nothing to match. In autumn the clock jumps back, so a stretch of local time happens twice. A job set inside it has two chances to match. The scheduler has to decide what to do, and the documentation of the common ones gives three different answers.
Spring: the hour that does not exist
Take a job set for 02:30 every day in a zone that moves from 02:00 to 03:00 on one night in spring. That night there is no 02:30. Three behaviors are documented by three sources.
The crontab(5) manual page of cronie says that non-existent times, such as the missing hours during the daylight saving conversion, will never match, which causes jobs scheduled during the missing times not to be run. The cron(8) page of the same project says that jobs that would have run in the skipped interval are run immediately after the change. GitHub's documentation for scheduled workflows says that, for a schedule in a zone that observes daylight saving time, workflows in skipped hours advance to the next valid time, so a 2:30 AM schedule advances to 3:00 AM.
So the same job is missed, run immediately, or moved to 3:00, depending on the system. None of them is a bug. They are three different promises, and you need to know which one your system makes.
Autumn: the hour that happens twice
In autumn, a job set for 01:30 meets two 01:30s in a zone that moves from 02:00 back to 01:00. The crontab(5) page of cronie says that times that occur more than once will cause matching jobs to be run twice. The cron(8) page says that if time was adjusted backward, running the same job twice is avoided.
GitHub's documentation, in the section on schedules, speaks only of the spring change and does not say what happens in autumn. A reader who needs to know has to test it or avoid the hour. A job that sends an email, charges a card, or writes a record is a bad choice for an hour that may run twice.
Two manual pages, one program
The crontab(5) and cron(8) pages above are both part of the cronie project, and they describe different behavior. The crontab(5) page, which credits Paul Vixie as author, states the plain rule that skipped times never match and repeated times match twice. The cron(8) page has a section called Daylight Saving Time and other time changes, which describes special handling.
That section says that local time changes of less than three hours, such as those caused by daylight saving time, are handled in a special way. It applies only to jobs that run at a specific time and jobs that run with a granularity greater than one hour, and jobs that run more frequently are scheduled normally. Time changes of more than three hours are treated as corrections to the clock or the zone, and the new time is used at once.
The practical reading is that the special handling is what the daemon is meant to do for fixed-time jobs, and the older text is a statement of the plain rule. If you rely on either, test on your own system, with your own version of cron, and do not assume that all Unix systems behave the same.
Cloud schedulers have their own rules
GitHub Actions runs scheduled workflows in UTC by default, and the documentation says that you can specify a zone with an IANA time zone string. The shortest interval is once every 5 minutes. The documentation adds that the schedule event can be delayed at times of high load, especially at the start of every hour, and that some queued jobs may be dropped if the load is high enough. Scheduling a workflow at a different minute of the hour lowers the chance of a delay.
Kubernetes treats CronJobs as follows. For a CronJob with no time zone, the kube-controller-manager interprets schedules relative to its own local time zone. You can set the zone with the spec.timeZone field, and the documentation says that using CRON_TZ or TZ inside the schedule is not officially supported and is rejected with a validation error. It also says that a CronJob creates a job approximately once per execution time of its schedule, and that there are circumstances in which two jobs are created or none is created, so the jobs that you define should be idempotent.
The common message of these pages is the same as the advice of this guide. A schedule is a request that is carried out approximately, and a job must be written to survive a run that is late, missing, or doubled.
The rules change without much warning
Time zone rules are not constant. Governments change the dates of daylight saving time, drop it, or adopt it, and the changes are sometimes announced only weeks ahead. The IANA Time Zone Database, often called tz or zoneinfo, holds the code and data that represent the history of local time for many representative locations, and it is updated whenever the rules change. Operating systems, runtimes, and containers use their own copies of it.
At the time of writing, the IANA page lists release 2026f, published on 27 October 2026, and its notes include a change to the rules for Cuba, which will not turn its clocks back on 1 November 2026. A server whose copy of the database is old will use the old rule and run jobs at the wrong hour. Keep the time zone data of your systems up to date, and remember that a container image may have an old copy inside it.
How to avoid the problem
The safest fix is to remove the dependency on local time. Set the server to UTC, or give the scheduler a UTC schedule, and let the application convert to local time when it needs to. UTC has no daylight saving time, so no hour is skipped or repeated. The cost is that a job meant for a certain local hour, such as 09:00 in a particular city, then moves by an hour in local terms when the city changes its clocks, and for a few jobs that is not acceptable.
For those jobs, avoid the hour of the change. The hours when the clocks change differ between countries, and in many places the change happens in the early hours of the morning, so a job set to a time in the middle of the day is not affected. Check the dates for your own zone, and do not rely on a rule that you remember.
- Run jobs in UTC when the local hour does not matter.
- Avoid scheduling in the hours around a clock change in the zone that the scheduler uses.
- Make each job idempotent, so that a second run does no harm.
- Use a lock or a record of the last run, so that a doubled run is noticed and stopped.
- Log the start and end of every run, with the time zone, so that you can see what happened.
- Keep the time zone database of servers and containers up to date.
- Move jobs that start every hour on the hour away from the busiest minute when the scheduler is shared.
Jobs that run often are mostly safe
A job that runs every few minutes is not troubled by a skipped hour in the same way, because it has many chances to run, and the cron(8) page says that jobs that run more frequently are scheduled normally. The loss is one hour of runs, which is usually acceptable. A job that runs once an hour or once a day at a fixed time is the one that matters.
The risk in the other direction is a job that does something every hour that should happen only once per hour of the real clock. When the clock goes back, the same local hour repeats, and a job that keys its work on the local hour can do it twice. Keying on UTC time, or on a unique identifier, avoids that.
How to find out whether your schedule is affected
Work out whether any run of your schedule falls in a gap or a repeated hour in the next year. For a schedule such as 30 2 * * * in a zone with daylight saving time, the answer is yes, once in spring and once in autumn. For 30 9 * * * the answer is no. The cron expression explainer on this site lists every run of a schedule in the next year that lands in a skipped or repeated hour, so you can see it before the night arrives.
Then check the rule of your scheduler against the three behaviors above. If your job is idempotent and a run may be late, the schedule is probably fine. If it must run exactly once, move it. Finally, put the clock change dates in a calendar and look at the logs the next morning at least the first time, because a documented behavior and the actual behavior of a particular version are not always the same.
Practical checklist
- Find out which clock your scheduler uses: local time, UTC, or a zone that you set.
- Check whether any run of each schedule falls in a skipped or repeated hour.
- Run jobs in UTC when the local hour does not matter.
- Move jobs that must run exactly once out of the hours around clock changes.
- Make jobs idempotent, and guard against a doubled run.
- Log every run with its time zone.
- Keep the time zone database up to date on servers and in container images.
- Test the behavior on your own system, and read the logs after the first clock change.
Research and references
This guide was prepared from the authoritative references below.



