Back to blog

Why Your GitHub Actions Scheduled Workflows Run Hours Late

GitHub Actions treats cron schedules as best-effort. In 2026 the delays are getting worse, with jobs firing hours late and some dropped entirely. Here is why, and how to catch it.

CronGuard TeamCron Job Monitoring Experts
Updated 10 min read
A dark monitor photographed at an angle, filled with syntax-highlighted source code and line numbers running down the left edge

A Scheduler That Does Not Promise a Schedule

You add a schedule block, set it to 0 6 * * *, and assume the job runs at 06:00 UTC. Most days it roughly does. Then one morning the run lands at 14:30. Another morning it does not land at all, and nothing in the Actions tab explains why. From GitHub's side nothing failed. The run was queued, the queue was busy, and the job waited.

You cannot file this as a bug. GitHub's own docs say the schedule event "can be delayed during periods of high loads of GitHub Actions workflow runs," that "high load times include the start of every hour," and that "if the load is sufficiently high enough, some queued jobs may be dropped." A dropped job produces no run, no log, no notification. The schedule is a request, not a guarantee.

The short answer, then: the delay comes from GitHub's shared queue, you cannot remove it from your side, and the one dependable defence is a check-in that something outside GitHub expects. The setup is in Monitor for the Missing Run. The rest of this post is the evidence.

The Delays Got Worse Through 2026

The gap between "occasionally late" and "unusable for anything time-sensitive" widened over the year, and people tracked it in the GitHub community discussions.

A Nightly Job Drifting Toward Four Hours

One thread from May 2026 logged a nightly workflow set for 00:40 UTC. The author had a year of timestamps: an average delay near 1 hour 40 minutes in 2025, up to 4 hours 30 minutes by that May. The drift was not noise. It grew, month over month, on the same workflow that used to run close to schedule.

Hours Late, Then Dropped Entirely

A July 2026 thread was uglier. A daily job fired 14.5 hours late on the 6th, 12.5 hours late on the 7th, did not run at all on the 8th, and stayed in the 8-to-12-hour band for the rest of the week. Moving the cron minute changed nothing. Underneath both threads sits the usual row of "same here" replies, each with its own timestamps.

Five Hours Late in October, Off the Hour

A thread opened on 21 October 2026 shows it has not eased. The workflow was scheduled for 16:53 JST, which is 07:53 UTC, off the top of the hour. On 14 October it started at 22:18 JST. On 20 October it started at 22:13 JST. More than five hours late, twice in a week. The runs themselves succeeded, they just ran in the evening instead of the afternoon, and the thread has no answer from GitHub staff. A reply there links three more October threads: one where schedule events arrived over five hours late, and two where scheduled runs went missing while manual runs worked.

Why the Top of the Hour Is the Worst Slot

The cause is shared, multi-tenant capacity. Every scheduled workflow on GitHub competes for the same runner pool at the same instants, and the popular instants are round numbers: the top of the hour, midnight UTC. A line of 0 * * * * asks to run at the moment the largest number of other repos also asked to run.

GitHub's advice is to step away from those peaks:

on:
  schedule:
    # Avoid the top of the hour, pick an odd minute
    - cron: "23 6 * * *"

Minute 23 or 47 helps on a normal day, because you leave the thundering herd. It does nothing on a bad day, when the backlog is measured in hours and a seven-minute head start is noise. The July and October reports came from people who had already moved off :00.

Time Zones Arrived. Punctuality Did Not.

Since March 2026 a schedule can carry an IANA timezone next to the cron line. A job meant for 06:00 in Amsterdam no longer needs a UTC offset that is wrong for half the year:

on:
  schedule:
    - cron: "23 6 * * 1-5"
      timezone: "Europe/Amsterdam"

That changes the moment the run is queued for. It does not change how long the run then waits in the queue, so everything above still applies.

The docs also cover only half of daylight saving time. In the spring gap, a schedule inside the skipped hour advances to the next valid time: 02:30 becomes 03:00. What happens to a schedule inside the hour that repeats in autumn is not documented. If running twice would hurt, do not guess. The repeated hour is a problem of its own, and it is easier to keep jobs out of it than to find out the hard way.

Dropped Runs Are Not Late Runs

A late run is annoying. A dropped run is dangerous, because the two look identical until the deadline passes. There is no "missed" state in the Actions UI. A run that never gets scheduled simply is not there. If your workflow renews a certificate, rotates a token, or publishes a nightly build, the absence of the run is the failure, and you hear about it from whatever breaks next.

It is the same trap as a cron job that stops firing, with one twist. On your own host you can usually grep the logs and confirm cron tried, unless the OOM killer took down the cron daemon itself and left the same silence. On GitHub Actions there is nothing to grep at all.

Public Repos Get Switched Off Silently

There is a second way a scheduled workflow dies quietly. In a public repository, GitHub disables scheduled workflows after 60 days without repository activity. A quiet utility repo, say a status-page updater or a mirror sync, can cross the two-month mark with no commits. Its schedule switches off, and no email goes out. The job comes back only when someone pushes or re-enables it by hand.

What You Can and Cannot Fix

Move Off the Peak, but Do Not Trust It

Pick an odd minute and stay away from 0 and 30. It trims the routine delay. Treat it as a small optimisation and never hang a hard deadline on it.

Use a Real Scheduler for Hard Deadlines

Some jobs must run at a specific time: a market-open task, an end-of-day close, a billing cutoff. For those, GitHub Actions is the wrong trigger. Run the schedule somewhere with an SLA, such as a cloud scheduler or a systemd timer on a host you control, and expose the workflow through workflow_dispatch so that scheduler can call it through the API at the right moment. GitHub still does the work. Something else owns the clock.

on:
  workflow_dispatch:
  # keep a loose cron as a fallback, not the primary trigger
  schedule:
    - cron: "23 6 * * *"

This setup comes with two catches. Keep the cron fallback and you have two triggers, and on a bad day the delayed scheduled run shows up hours after the dispatched one finished. A concurrency group stops the two from overlapping, but the second run still happens, so the workflow has to be safe to run twice. That is the same problem as running cron on more than one server, with the same fixes.

The other catch is that the new clock can fail quietly too. A scheduler library inside your own app is the tempting option, and APScheduler shows how that goes wrong: the scheduler thread dies with the process and nobody gets told.

Stop Reading Silence as Success

GitHub emails you when a workflow fails. It does not email you when a workflow never starts. A quiet inbox tells you nothing about the runs that were dropped, and that single distinction is the whole problem.

Monitor for the Missing Run

The failure mode here is absence, so the only monitoring that catches it watches for the absence of success. Have the workflow check in at the end of a successful run, and have something outside GitHub expect that check-in. A run four hours late produces a check-in four hours late, and you see the drift. A run that gets dropped produces no check-in, and you get paged, without GitHub ever having to report a thing.

jobs:
  nightly:
    runs-on: ubuntu-latest
    steps:
      - name: Do the actual work
        run: ./scripts/nightly-sync.sh
      - name: Check in
        run: curl -fsS --retry 3 https://www.cronguard.app/api/ping/your-monitor-id

Put the check-in as the last step, so it only fires when everything before it succeeded. Set the monitor's period to your real schedule plus a grace window wide enough to swallow the normal drift. An ordinary late run then stays quiet, and a genuinely missing one wakes you up.

How wide is wide enough? Going by the reports above, a daily workflow needs a grace period measured in hours. Six is a reasonable start. Tighten it once your own check-ins show what a normal week looks like.

That expectation is what CronGuard is for. Create a monitor with the workflow's schedule, set a grace period of up to 24 hours, and paste its ping URL into that last step. The free plan has five monitors, which covers the scheduled workflows of most repositories. Set up a free monitor, or read the docs first to see how pings and alerts work.

Frequently asked questions about GitHub Actions scheduled workflows

Why did my scheduled workflow run hours late? GitHub Actions runs scheduled workflows on shared capacity, and the schedule event is delayed during high load. The start of every hour is a documented high-load window, so a job set for that slot waits behind everyone else's. Through 2026 users reported the delay growing from under two hours to more than five by October, including jobs scheduled off the top of the hour.

Can a scheduled workflow be skipped entirely? Yes. GitHub's documentation says that if load is high enough, some queued jobs may be dropped. A dropped run leaves no entry in the Actions tab, no log, and no failure email, so it looks identical to a run that has simply not started yet.

Does changing the cron minute fix the delay? It helps on a normal day and not at all on a bad one. Moving off minute zero to something like 23 or 47 steps you out of the busiest slot and shaves routine delay. When the backlog runs to hours, a few minutes of offset make no difference, which is what people who already left the top of the hour keep reporting.

Why did my scheduled workflow stop running on its own? In a public repository, GitHub disables scheduled workflows after 60 days without repository activity. A low-traffic repo can pass that line with no commits, its schedule switches off silently, and it resumes only once someone pushes a change or re-enables it by hand.

How do I get alerted when a scheduled workflow does not run? Add a check-in as the final step of the job and point it at an external monitor that expects it on your real schedule. A late run makes the check-in late and you see the drift; a dropped run means the check-in never arrives and the monitor alerts you. This watches for the absence of success, the only signal that catches a run GitHub never started.

Further reading


Conclusion: GitHub Actions schedules are best-effort, and in 2026 that "best" drifted to hours late with runs dropped outright. The new timezone option fixes which hour you ask for, not when you get it. You cannot fix the shared queue. You can stop trusting it blindly: move off the top of the hour, hand any hard deadline to a scheduler with an SLA, make the job safe to run twice, and monitor for the absence of a successful run so a dropped job pages you instead of surfacing as the next thing that breaks.

Sources: GitHub Actions schedule event documentation, GitHub changelog, late March 2026 Actions updates.

Share

Related posts

A dark computer monitor showing blurred lines of code in orange and white, with a blue glow in the lower left corner and a red light strip beside a second screen on the right
ReliabilityA Kubernetes Job Recreated Under the Same Name Can Sit at Zero Pods
A person at a desk in a dark room, lit by two monitors filled with lines of code, looking toward the camera, in black and white
ReliabilityThe Kubernetes CronJob Deadlock That Stops Your Schedule For Good
Close-up of a numbered network patch panel with blue and gray Ethernet cables plugged into labelled ports
DevOpsKubernetes Job Suspension and Why It Creates a Monitoring Blind Spot

Set up your first monitor.
It'll take 30 seconds.