If you run backups, database cleanups, or report syncs with GitHub Actions on: schedule, it is easy to assume GitHub will email you when something breaks.

It will, if the workflow actually starts and exits with an error.

The harder failure mode is when the workflow never runs at all. There is no failed job, no red X, and no email. You only find out weeks later when you go looking for a backup that stopped existing last month.

Three ways on: schedule goes silent

1. The 60-day inactivity auto-disable

In a public repository, GitHub automatically disables scheduled workflows if there has been no repository activity for 60 days. Utility repos (like a standalone backup or data-sync repo) hit this constantly. You push a working workflow, leave it alone because it works, and two months later it quietly stops running.

2. Best-effort scheduling and dropped runs

GitHub treats on: schedule as best-effort. During peak load (especially at the top of the hour: 0 * * * *, 0 0 * * *), scheduled jobs can sit in the queue for 15 to 60 minutes. Under heavy load, queued scheduled runs can be dropped completely without creating a failed run.

Moving your cron off :00 (for example, 17 3 * * * instead of 0 3 * * *) reduces queue contention, though it does not eliminate missed runs entirely.

3. Broken config or exhausted minutes

A YAML syntax error pushed to the default branch, an exhausted billing limit on a private repo, or a manually disabled workflow all produce the same result: zero runs and zero failure notifications.

The fix: a dead-man's switch (heartbeat)

Instead of waiting for GitHub to report a failure, invert the check: have your job ping an external URL only when it finishes cleanly. If the expected ping does not arrive on time (plus a grace window), you get alerted.

That catches both failure modes at once:

  • The job started and failed midway: the final step never runs, so you get an alert.
  • GitHub disabled, delayed too long, or dropped the schedule: the job never starts, so you get an alert.

Option 1: Plain curl (works with any heartbeat service)

Because GitHub Actions only runs a step when every step before it succeeded, put the ping at the very end of the job:

name: Nightly backup on: schedule: - cron: "17 3 * * *" jobs: backup: runs-on: ubuntu-latest steps: - uses: actions/checkout@v4 - run: ./backup.sh # Runs only if every step above succeeded  - name: Send heartbeat if: env.HEARTBEAT_URL != '' env: HEARTBEAT_URL: ${{ secrets.HEARTBEAT_URL }} run: curl -fsS --max-time 10 --retry 3 "$HEARTBEAT_URL" 

A few details that save headaches later:

  • Store the URL as a repository secret. Anyone with the URL can fake a successful ping, and keeping it in Secrets prevents it from leaking in public workflow logs.
  • Guard against empty secrets. If the workflow ever runs from a fork (for example, if you also trigger on pull_request), GitHub omits repository secrets. Without the if: env.HEARTBEAT_URL != '' guard, curl fails on every fork PR.
  • Always add --max-time and --retry. A brief network blip on the monitoring side should not hang your runner or fail an otherwise healthy backup.
  • Remember GitHub cron is always UTC. When you configure the schedule on your monitoring service, match UTC (or convert to your project's timezone) so you do not get false alarms across daylight saving changes.
  • Give yourself a realistic grace window. Account for GitHub's queue delay plus the job's own runtime. For a nightly job that takes 5 minutes, a 45 to 60 minute grace period avoids noisy alerts when GitHub Actions queues back up.

This pattern works with any dead-man's switch: Healthchecks.io, Cronitor, Better Stack, You Up?, or a small script of your own.

Option 2: A 3-line Action (if you don't want to copy-paste curl flags)

Full disclosure: I build You Up?, an uptime and cron monitoring service. After repeating the same secret-guard and retry shell snippet across repos, we packaged it into a small, zero-dependency MIT GitHub Action (uupdev/heartbeat):

 - uses: uupdev/heartbeat@v1 with: url: ${{ secrets.UUP_HEARTBEAT_URL }} 

By default it uses a 10-second timeout, retries up to 3 times on network or 5xx errors, masks the URL in logs, skips cleanly when the secret is empty (such as on forks), and logs a warning instead of failing your backup job if the ping itself cannot get through (configurable via fail-on-error: true). Full inputs and post-deploy examples are in the GitHub Action docs, and plain curl snippets for crontab, systemd, and Kubernetes are in the heartbeat examples.

Quick checklist before you rely on on: schedule

  1. Shift schedules off :00 (e.g. minute 17 or 43) to dodge peak GitHub queue congestion.
  2. Add a final-step heartbeat ping stored in Secrets, with a timeout, retries, and an empty-secret guard.
  3. Double-check UTC vs. local timezone on your monitor's schedule.
  4. Set a grace window large enough for GitHub's worst-case queue delay plus job duration.