Your cron job exited 0. It loaded 0 rows.
normbeat will learn what a normal run looks like for each of your jobs, Mondays and Sundays separately, and alert you when a count comes in at zero, far too low, or suspiciously high. There will be no threshold to set. Your job will just send its row count with a ping.
In development. Free to join. No database credentials needed, now or later.
orders_loadrows per run · daily 02:00
- Out of range Tue · exit 0 · rows=0 · expected 41k–52k
- OK Sat · 9.8k · normal for a Saturday
- learned normal range, by day of week
- rows < 20k rule would page every weekend
The job said done. The table was empty.
A nightly job pulls orders from an API and loads them into Postgres. One night the API sends back an empty list instead of an error. The script loops over nothing, commits nothing, and exits 0.
Cron is happy. Your heartbeat monitor is happy. The log says done.
On Thursday someone in finance asks why the dashboard shows no sales since Tuesday. Now you're backfilling two days, re-running everything downstream, and explaining a gap that every check said wasn't there.
It isn't always an empty API. A source file arrives cut off halfway. An expired token gets you 200 OK and []. The job did what it was told. The output was wrong.
An exit code tells you the process finished. It doesn't tell you the process did any work.
"Alert if rows < 100,000" works until Saturday.
The obvious fix is a rule: if the count drops below some number, page me. Plenty of tools let you write that rule, and for a job that loads the same amount every day, it's fine.
Most data jobs don't. One engineer wrote about setting a hard minimum of 100,000 records a day. Weekday volume sat well above it. Weekend volume for that source is normally 20,000 to 30,000. The rule paged them every Saturday and Sunday morning, three weekends in a row, for normal weekend data. Their fix was to compare each day with the same weekday in past weeks.
You can patch it by hand. Lower the number, and a weekday load that comes in badly short slips under it. Or you add a weekend rule, then a month-end rule, then one for the holiday week. Every job ends up with its own little pile of thresholds, and somebody has to keep them current.
normbeat will do that comparison for you. It will keep each job's history and learn its normal range by day of week, so a quiet Saturday is compared with other Saturdays, not with a busy Tuesday. When a run lands well outside what that job usually does on that day, you'll hear about it. When it doesn't, you won't.
Three steps. One extra line at the end of your job.
-
Create a check
Give it a name and a schedule, like "orders load, daily at 02:00". You'll get a ping URL for it.
-
Send the count when the job finishes
At the end of your script, send the number of rows you loaded. Or files written, or records processed: whatever number shows the job did its work. Cron, a plain Python script and Airflow tasks will all work. An Airflow integration is planned.
-
Let it learn, get alerted when a run looks wrong
normbeat will build a normal range from that job's own runs. Learning a weekly pattern will take a few weeks of history. From the start, you'll still get alerts for missed runs, late runs, failures and zero counts. Alerts will go to email or Slack, and each check will keep a run history with a small chart of the count over time.
Planned API. May change before launch.
fail if the load errors)#!/usr/bin/env bash
PING="https://normbeat.com/ping/YOUR_CHECK_ID"
if rows=$(python3 load_orders.py); then
curl -fsS -m 10 "${PING}?rows=${rows}"
else
curl -fsS -m 10 "${PING}/fail"
exit 1
fi
import requests
PING = "https://normbeat.com/ping/YOUR_CHECK_ID"
try:
rows_loaded = run_orders_load() # your existing job, returns a row count
except Exception:
requests.get(PING + "/fail", timeout=10)
raise
requests.get(PING, params={"rows": rows_loaded}, timeout=10)
You decide what to count. normbeat will never connect to your database. All it will see is the number your job sends. An open-source Python client is planned so this becomes one line.
Six alerts. You won't have to configure any of them.
| Alert | What it means |
|---|---|
| Didn't run | No ping arrived in the expected window. The job never started, or the scheduler is down. |
| Late | The ping came, but well after its usual time. Downstream jobs may have run on stale data. |
| Failed | Your job reported a failure. |
| Zero | The job "succeeded" and reported 0. The classic silent success. |
| Far too low | The count is well below this job's normal range for that day of the week. For example, 312 rows on a Tuesday that usually brings in about 48,000. |
| Suspiciously high | The count is well above normal. A retry that loaded the same day twice, or a missing dedupe step, shows up here. |
Alerts will go by email and Slack. Numbers in the examples are illustrations, not data from real users.
If you already have a cron monitor, here's what's different.
Some good tools already watch scheduled jobs, and some of them can check a count too. Here's what each one's public docs describe, as of November 2026:
| Tool | What it does with your job's numbers |
|---|---|
| Healthchecks.io | Alerts when a job doesn't check in on time or reports a failure (including through its exit status). It stores the ping body and can treat a ping as success or failure based on keywords in it. Its docs don't describe alerting on a number in the ping. |
| Cronitor | Accepts a count with each ping and lets you write rules on it, like metric.count > 0. It also supports rules on aggregates over a time window, such as a mean over the last 24 hours. You choose the threshold. |
| DeadManCheck | Open source and self-hostable. You include a count in the ping, and it checks it against rules you write, like count > 0. It learns each job's normal runtime on its own. |
| Crontify | You attach values like rows processed to a ping and define alert rules against them. It flags runs that take much longer than their usual duration. |
I've tried to describe these tools fairly from their own documentation. If I've got something wrong or it's out of date, email hello@normbeat.com and I'll fix it.
What normbeat will do differently
- It will learn the normal count for you. No rule to write, no number to pick. The range comes from the job's own history.
- It will know what day it is. A Saturday gets compared with other Saturdays. That's the case where fixed thresholds page you for nothing.
- It will check both sides. Far too low and suspiciously high, from the same learned range.
- It's being built for data jobs. Python client, Airflow integration planned, and docs written in terms of loads, rows and partitions rather than servers.
If one of these tools already covers you, keep it. You'll be able to run normbeat next to it, or use normbeat alone, since it will also cover didn't-run, late and failed.
Who it's for
Solo data engineers and small data teams running Python, cron or Airflow jobs into Postgres, S3, BigQuery and similar. If your pipelines are mostly dbt models, a dbt-native tool will probably suit you better.
Planned pricing
Planned, not final. Early-access members will get a discount at launch.
Free
$0 (planned)
- A few monitors (planned: 3 to 5), including at least one data check
- Email alerts
- For side projects and trying it out
Paid
From about $12 to $19 a month (planned)
- More monitors and data checks
- Email and Slack alerts, run history
- Priced per account, not per user
A larger tier for teams with many jobs is also planned. No sales calls. You'll sign up and pay online.
FAQ
How will it know what's normal for my job?
From the counts your job sends. It will keep a history per check and work out a normal range for each day of the week, so weekend dips and busy Mondays are expected rather than flagged. Learning a weekly pattern will take a few weeks of runs. Until then you'll still get alerts for zero counts, missed runs, late runs and failures.
Cronitor and DeadManCheck can already alert on a count. Why would I use this?
They can, and if a fixed rule like count > 0 or "below 10,000" works for your job, they're a reasonable choice. normbeat is for jobs where a fixed number doesn't fit: volume that changes by day of week, or many jobs where you don't want to pick and maintain a threshold for each one. It will learn the range for you and alert on both too low and too high.
Do you need my database credentials?
No. normbeat will never connect to your database, warehouse or bucket. Your job will count its own output and send that number in the ping. That number is all normbeat will see.
What if my job doesn't load rows? It writes files or calls an API.
Send whatever number shows the job did its work: files written, bytes, records sent. If it's usually above zero, normbeat will be able to learn its pattern.
Is it open source?
The Python client that sends pings is planned as open source, so you can read exactly what it sends. The hosted alerting will be the paid part. You'll also be able to skip the client and use plain curl.
When does it launch?
It's in development. There's no launch date yet. People on the waitlist will get access before the public launch, and updates by email.
Who's building it?
Me, a backend and ETL engineer working on this alone. I've had jobs report success with nothing to show for it, and I've been paged on Saturdays by thresholds that were set for Tuesdays. normbeat will be the tool I wanted for both problems.
Get early access
Join the waitlist and try normbeat before the public launch.
You're on the list. I'll email you when early access opens. If you skipped the story box, you can reply to that email with one. I'd like to hear it.
Your signup didn't go through. Please try again in a moment.