Skip to main content
Background Job Monitoring

Know When Your Background Jobs Stop.

Scheduled jobs, background workers, and long-running processes — when they fail silently, you don't know until it's too late. FlareWarden detects missed runs, hung jobs, and silent failures with a single curl command.

Start Free Monitoring Read the Docs
3
Signals
5
States
3-Line
Setup
Zero
Agents Required
Scheduled Jobs

Cron expressions or fixed intervals. Start/complete/fail lifecycle. For backups, ETL pipelines, report generation.

Always-On Workers

Single ping heartbeat. No lifecycle — just check in periodically. For queue consumers, daemons, background workers.

Complete Cron Visibility

Every Job. Every Run. Every Signal.

FlareWarden watches your scheduled jobs from the inside. Add a curl command and get alerts when anything goes wrong.

Missed Run Detection

Alert fires when a job doesn't ping by expected time plus grace period.

Hung Job Detection

Job started but never completed? Catch it when max run duration is exceeded.

Explicit Failure Reporting

Ping /fail with error messages and metadata for instant incident creation.

Schedule Flexibility

Cron expressions, simple intervals, or heartbeat check-ins. Every scheduling pattern covered.

Configurable Grace Periods

Tight windows for critical jobs, generous windows for jobs that naturally vary in runtime.

Status Page Integration

Cron monitors appear on your public status page alongside uptime, SSL, and content monitors.

Scheduled Jobs

Start. Complete. Or We Alert.

For jobs that run on a cron expression or fixed interval. Your job pings start when it begins and complete when it finishes. If it never starts, hangs mid-run, or reports failure — FlareWarden catches it.

Three signals: /start, /complete, /fail
Hung job detection: max run duration catches jobs that start but never finish
Cron or interval: 0 2 * * * or every 8h
Metadata on fail: error messages, exit codes, custom key-value pairs
Always-On Workers

One Ping. Always Watching.

For processes that run continuously — queue consumers, daemons, and background workers. They check in periodically with a single ping. If check-ins stop, FlareWarden alerts you immediately.

Single ping URL: no start/complete lifecycle — just one endpoint
Deploy-safe grace periods: set buffer time above your restart duration to avoid false alerts
Same dashboard: heartbeat monitors live alongside cron monitors with unified alerting
Use Cases

Built for Every Background Job

Whether it runs on a cron schedule, a fixed interval, or continuously — FlareWarden has you covered.

Database Backup

Cron Expression

Nightly pg_dump at 2am. Start signal when it begins, complete when the dump finishes. Know within minutes if last night's backup never ran.

0 2 * * * · 30m grace · start/complete

ETL Pipeline

Interval

Data sync every 8 hours. Max run duration catches hung transforms. Fail signal captures the exact error message for fast debugging.

every 8h · 1h grace · 30m max run

Queue Worker

Heartbeat

Sidekiq, Celery, or custom workers check in every 5 minutes. One ping URL, no lifecycle. If the worker dies, you know in under 10 minutes.

every 5m · 5m grace · single ping
Integration

Works With Every Stack. No SDK Required.

Just HTTP. Add a curl command to your shell script, or a single HTTP call in any language. No agents, no libraries, no firewall rules.

backup-database.sh
#!/bin/bash

curl -s https://app.flarewarden.com/ping/abc123/start

# Your actual job
pg_dump mydb > backup.sql 2>&1

if [ $? -eq 0 ]; then
  curl -s https://app.flarewarden.com/ping/abc123/complete
else
  curl -s https://app.flarewarden.com/ping/abc123/fail
fi
backup.py
import requests

PING = "https://app.flarewarden.com/ping/abc123"

requests.post(f"{PING}/start")

try:
    run_backup()
    requests.post(f"{PING}/complete")
except Exception as e:
    requests.post(f"{PING}/fail", json={"error": str(e)})
backup.mjs
const PING = "https://app.flarewarden.com/ping/abc123";

await fetch(`${PING}/start`, { method: "POST" });

try {
  await runBackup();
  await fetch(`${PING}/complete`, { method: "POST" });
} catch (err) {
  await fetch(`${PING}/fail`, {
    method: "POST",
    body: JSON.stringify({ error: err.message }),
  });
}
main.go
ping := "https://app.flarewarden.com/ping/abc123"

http.Post(ping+"/start", "", nil)

if err := runBackup(); err != nil {
    http.Post(ping+"/fail", "application/json",
        strings.NewReader(`{"error":"`+err.Error()+`"}`))
    return
}
http.Post(ping+"/complete", "", nil)
backup.rb
require "net/http"

ping = URI("https://app.flarewarden.com/ping/abc123")

Net::HTTP.post(URI("#{ping}/start"), "")

begin
  run_backup
  Net::HTTP.post(URI("#{ping}/complete"), "")
rescue => e
  Net::HTTP.post(URI("#{ping}/fail"),
    { error: e.message }.to_json,
    "Content-Type" => "application/json")
end
backup.php
<?php
$ping = "https://app.flarewarden.com/ping/abc123";

file_get_contents($ping . "/start");

try {
    run_backup();
    file_get_contents($ping . "/complete");
} catch (Exception $e) {
    file_get_contents($ping . "/fail", false,
        stream_context_create(['http' => [
            'method' => 'POST',
            'content' => json_encode(['error' => $e->getMessage()])
        ]]));
}

No SDK or library needed — any language that speaks HTTP works out of the box.

State Machine

Five States. Zero Confusion.

Every cron monitor has a clear, unambiguous state. No guesswork about whether your job ran, is still running, or failed silently.

Pending: waiting for the first ping after creation
OK: completed successfully within the expected schedule
Running: start signal received, waiting for completion
Late: expected run time plus grace period exceeded
Failed: job reported an error or exceeded max run duration
Run History

See Every Run. Diagnose Fast.

FlareWarden records every run with timing data, duration, exit codes, and custom metadata. Visualize runs across 24 hours, 7 days, or 30 days.

Timeline visualization: see run patterns at a glance
Duration tracking: spot jobs that are getting slower over time
Error messages: captured from the fail endpoint for quick debugging
Custom metadata: key-value pairs for context-specific debugging
Job Intelligence

Everything You Need to Debug

Each run is recorded with full metadata so you can diagnose issues without SSH-ing into your server.

Timing
  • Expected Schedule
  • Actual Run Time
  • Grace Period
  • Duration
Health
  • Current State
  • Last Success
  • Failure Count
  • Consecutive Failures
Metadata
  • Exit Codes
  • Error Messages
  • Custom Key-Values
  • Payload Size
Integration
  • Parent Monitor
  • Status Page
  • Webhook Events
  • Alert Routing
Alerting

When a Job Fails, You Know Immediately.

Silent failures are the whole reason cron monitoring exists. FlareWarden doesn't just detect problems — it makes sure the right people find out, through the right channels.

Email alerts: immediate notification to your team when a job goes Late or Failed
Webhook delivery: push events to Slack, PagerDuty, or your own systems via HTTP POST
Automatic incidents: Late and Failed states create trackable incidents with full context
Maintenance windows: pause alerting during planned downtime to avoid noise
Recovery alerts: get notified when a failed job runs successfully again
Simple Setup

How It Works

Three steps. Under two minutes. No agents to install.

1

Create a Cron Monitor

Open any uptime monitor, click Add Cron Monitor, set your schedule and grace period. Copy the unique ping URL.

2

Add a Curl Command

Add a single curl call to your cron script. Start, complete, and fail endpoints are generated automatically.

3

Get Alerts When It Matters

Missed runs, hung jobs, and explicit failures trigger alerts via email and webhook. Resolve from your dashboard.

Frequently Asked Questions

FlareWarden uses a push-based heartbeat model. Instead of polling your server, your cron jobs ping FlareWarden when they start, complete, or fail. If a ping doesn't arrive within the expected schedule plus grace period, FlareWarden knows the job missed its run and alerts your team immediately.

Add a single curl command to your cron job script. Curl the start endpoint when the job begins, the complete endpoint when it finishes, and optionally the fail endpoint on error. No agents to install, no firewall rules to configure — just outbound HTTPS.

Cron expressions use standard 5-field syntax (minute hour day-of-month month day-of-week) for jobs that run at specific times, such as "every day at 2am" or "every Monday at noon." Interval scheduling is for jobs that repeat every N minutes or hours regardless of clock time. Both support configurable grace periods to prevent false alerts.

Pending means the monitor is waiting for its first ping. OK means the job completed successfully and on time. Running means a start signal was received but the job hasn't finished yet. Late means no ping arrived after the scheduled time plus grace period. Failed means the job explicitly reported an error or exceeded its maximum run duration.

Yes. Cron monitors are children of a parent uptime monitor and can be included as components on your public status page. This gives your users visibility into background job health alongside your web services — all in one unified view.

Yes. Cron job monitoring is available on every plan, including the free plan. The number of cron monitors you can create depends on your plan tier, but every plan includes cron monitoring with full alerting capabilities.

Cron monitoring is for scheduled jobs that run on a defined schedule (daily backups, hourly reports). Your job sends start and complete signals, and FlareWarden alerts you if it misses a run. Heartbeat monitoring is for always-running processes (background workers, queue consumers, daemons) that periodically check in with a single ping. If the check-in stops arriving, you get alerted. Both are included on every plan.

Stop Guessing If Your Jobs Ran.

15 free monitors with cron job tracking. Add a curl command and know your background jobs are healthy.

Start Free Monitoring
Free plan — no expiration No credit card required Setup in under 2 minutes