Keep your cron.We verify results.

One curl line. Zero execution changes. Stop writing alert connectors.

14-day free trial · No credit card required

Monitor Everything in One Place

Real-time status updates and instant alerts for all your cron jobs

Active Monitors

4 monitors

Daily Backup

Expected every 24h

Database Sync

Expected every 1h

Report Generator

Expected every 6h

Health Check

Expected every 5m

The uncomfortable truth

Most cron jobs don't fail loudly.
They succeed… incorrectly.

zero rows processed

partial data

wrong counts

outdated results

skipped logic paths

And no alert fires.

Why existing monitoring tools fail here

Plain webhooks (Discord / Slack)

  • • You must write your own connectors
  • • Logic buried in scripts
  • • No shared state
  • • No recovery
  • • No "job didn't run" detection
  • • Every script behaves differently

After 10 jobs: "I don't remember which script checks what."

DeadManPing = Stop writing connectors. One curl line. Rest in the dashboard.

Error monitoring tools

  • • alerts only on exceptions
  • • requires code-level decisions
  • • thresholds = deploys
  • • no concept of "wrong result"

If your job returns count = 3 instead of 100, error trackers are silent.

Binary ping monitors

  • • binary signal: ping or no ping
  • • job ran ≠ job succeeded
  • • zero awareness of results

"The cron ran" is not the same as "The cron did its job."

Job schedulers (Jenkins, Airflow)

  • • Require migration from cron
  • • GUI-based configuration
  • • Vendor lock-in
  • • Complex setup and maintenance

DeadManPing works with your existing cron. No migration needed.

What DeadManPing is NOT

DeadManPing is not a job scheduler

DeadManPing does not run your jobs

DeadManPing does not replace cron

DeadManPing does not touch execution

DeadManPing only observes the effects of execution

What DeadManPing does differently

DeadManPing separates execution from evaluation.

Your cron runs your scripts.
Your scripts send facts.
DeadManPing decides if that's OK.

What You DON'T Need to Build

Connectors to Slack/Discord/Email

Everything is in the dashboard

Logic to check if job executed

DeadManPing does this automatically

State management

DeadManPing tracks state changes

Recovery logic

Alerts only on state change, no spam

Monitoring dashboard

Everything in one place

Payload validation logic

Rules in UI, not in code

Stop writing alert connectors. One curl line. Rest in the dashboard.

How It Works

1

Add one line at the end of your existing script

Cron runs your script. Your script executes logic and collects data. At the end of your script — one curl line with data from execution.

Important: Curl must be INSIDE the script, not in the cron line, because only in the script do you have access to variables from execution results.

# sync_users.sh

#!/bin/bash
users_synced=$(./sync_users_logic.sh)
if [ $? -eq 0 ]; then
  curl https://deadmanping.com/ping/abc123 \
    -H "Content-Type: application/json" \
    -d "{\"success\": true, \"count\": $users_synced}"
else
  curl https://deadmanping.com/ping/abc123 \
    -H "Content-Type: application/json" \
    -d '{"success": false}'
fi

# In crontab: */5 * * * * /path/to/sync_users.sh

  • • No SDKs.
  • • No branching logic.
  • • No alert decisions in code.
  • • Data comes from execution, not hardcoded.
2

Define rules in the dashboard

Example rules:

  • • success == true
  • • count >= 100 → OK
  • • count < 100 → WARN
  • • no ping for 15 min → FAIL

Change rules anytime. No redeploys.

3

Get state-aware alerts

DeadManPing tracks transitions:

  • • OK → FAIL
  • • FAIL → OK
  • • job didn't run
  • • result degraded but not broken

No spam. No silence.

Real-World Examples

Different types of verification that DeadManPing can monitor:

File Verification

Check if backup file exists and size (GB)

if [ -f "$BACKUP_FILE" ]; then
  FILE_SIZE_GB=$(du -h "$BACKUP_FILE" | ...)
  curl ... -d "{\"file_exists\": true, 
    \"size_gb\": $FILE_SIZE_GB}"
fi

Status Verification

Success/failure with context

if ./backup.sh; then
  curl ... -d "{\"success\": true, 
    \"backup_size\": \"$SIZE\"}"
else
  curl ... -d "{\"success\": false, 
    \"error\": \"$ERROR\"}"
fi

Duration Verification

How long script execution took

START_TIME=$(date +%s)
./generate_report.sh
DURATION=$((END_TIME - START_TIME))
curl ... -d "{\"duration_seconds\": $DURATION}"

Threshold Verification

Numeric values (more/less than X)

FILES_DELETED=$(./cleanup.sh | wc -l)
curl ... -d "{\"files_deleted\": $FILES_DELETED}"
# In dashboard: files_deleted >= 10 → OK, < 10 → WARN

Count Verification

How many records/items were processed

RECORDS_PROCESSED=$(./sync.sh | grep -c "synced")
curl ... -d "{\"count\": $RECORDS_PROCESSED}"

Key Differentiators

Result-aware monitoring

We monitor outcomes, not just execution.

Declarative rules

Rules live in the UI, not inside scripts.

Built-in recovery logic

Alerts fire on state change, not every run.

Missing-run detection

If your cron never executes — you still get alerted.

Zero custom logic per customer

Same payload schema. Same evaluation engine. No support burden.

What You Get

FeatureDeadManPing
Detect job didn't run✓
Inspect job results✓
Payload-based rules✓
Thresholds in UI✓
OK → FAIL tracking✓
Requires SDK✗
Requires code logic✗

Integrate with Your Workflow

Get alerts where your team already works

Discord

Real-time alerts in your Discord channels

Slack

Notifications directly in your Slack workspace

Email

Instant email notifications for critical alerts

Simple, Transparent Pricing

14-day free trial • No credit card required

Who This Is For

Built for:

  • • backend developers
  • • solo founders
  • • infra & ops
  • • data pipelines
  • • maintenance & batch jobs

Not for:

  • • realtime apps
  • • error debugging
  • • APM
  • • log aggregation

DeadManPing is not an error tracker.
It's a job outcome verifier.

Error trackers tell you when your job crashed.
DeadManPing tells you when it succeeded… incorrectly.

Stop trusting green checkmarks.

Monitor results, not assumptions.