How to monitor cron jobs in 2026. The complete guide.

Right now, somewhere in your infrastructure, a cron job is failing silently. Maybe it's a backup that stopped writing to disk. Maybe it's a data sync that's been timing out for a week. Maybe it's a cleanup script that broke after the last deploy.

You don't know. And you won't know — until a customer reports missing data, or a disk fills up, or an invoice doesn't go out.

This guide shows you how to fix that in 30 seconds per job.

Why cron jobs fail silently

The Unix cron daemon has one job: execute a command on a schedule. That's it. It doesn't care if the command succeeds. It doesn't track if the command finished. It doesn't alert anyone if the command never runs at all.

Every one of these scenarios results in the same thing: silence. No error in your inbox. No alert in Slack. Just a job that stopped working, and nobody who knows about it.

How heartbeat monitoring works

Heartbeat monitoring (also called dead man's switch monitoring) flips the approach. Instead of checking if a job is running, you check if a job stops running.

This catches every type of failure — script errors, server crashes, cron daemon issues, network problems. If the ping doesn't arrive, you know something is wrong. The reason doesn't matter. The alert does.

Set it up in 30 seconds

We'll use PingCron for these examples. The concept is the same for any heartbeat monitoring tool — but PingCron is free to start and takes 30 seconds to set up.

Code examples for every language

Every example below uses the same ping URL from PingCron. The pattern is identical: run your job, then ping. If the job fails, ping the /fail endpoint instead.

Bash (most common)

# Basic: ping after success
0 2 * * * /scripts/backup.sh \
  && curl -s https://api.pingcron.io/ping/abc123

# Better: report success or failure
0 2 * * * /scripts/backup.sh \
  && curl -s https://api.pingcron.io/ping/abc123 \
  || curl -s https://api.pingcron.io/ping/abc123/fail

# Best: report start, success, and failure
0 2 * * * curl -s https://api.pingcron.io/ping/abc123/start \
  && /scripts/backup.sh \
  && curl -s https://api.pingcron.io/ping/abc123 \
  || curl -s https://api.pingcron.io/ping/abc123/fail

The "best" version lets PingCron track job duration — you'll see how long each run takes in your dashboard.

Python

import requests

PING = "https://api.pingcron.io/ping/abc123"

def run():
    requests.get(f"{PING}/start")
    try:
        run_backup()
        requests.get(PING)       # success
    except Exception:
        requests.get(f"{PING}/fail")
        raise

if __name__ == "__main__":
    run()

Node.js

const PING = "https://api.pingcron.io/ping/abc123";

async function runJob() {
  await fetch(`${PING}/start`);
  try {
    await processData();
    await fetch(PING);           // success
  } catch (err) {
    await fetch(`${PING}/fail`);
    throw err;
  }
}

runJob().catch(console.error);

PHP

<?php
$ping = "https://api.pingcron.io/ping/abc123";

file_get_contents("$ping/start");
try {
    runMigration();
    file_get_contents($ping);    // success
} catch (Exception $e) {
    file_get_contents("$ping/fail");
    throw $e;
}

Go

package main

import "net/http"

const ping = "https://api.pingcron.io/ping/abc123"

func main() {
    http.Get(ping + "/start")
    if err := runBackup(); err != nil {
        http.Get(ping + "/fail")
        panic(err)
    }
    http.Get(ping) // success
}

Notice the pattern is identical in every language: signal start, run the job, signal success or failure. One URL. Three endpoints. That's the entire integration.

Best practices

What to monitor

If it runs on a schedule, it should have a heartbeat monitor. Here's a non-exhaustive list:

The cost of not monitoring

Consider what happens when each of these fails silently:

Every one of these is a real scenario that happens to real teams every week. The monitoring that would have caught them takes one line of code and costs nothing on PingCron's free plan.

Start now. Not after the next outage.

Cron jobs will fail. The only question is whether you find out in seconds or in weeks. Heartbeat monitoring is the simplest, most reliable way to ensure you know the moment something breaks.

The integration takes one line of code. The setup takes 30 seconds. The free plan covers 5 monitors with full alerting on email, Slack, Discord, and webhooks.

There is no reason to wait. The next silent failure is already happening.

Start monitoring your cron jobs.

Free plan. 5 monitors. All alert channels. 30-second setup.