Your cron job exited 0. It loaded 0 rows.
normbeat compares each run with that job's recent runs on the same weekday, Mondays with Mondays and Sundays with Sundays, and alerts you when a count comes in at zero, far too low, or suspiciously high. No thresholds required. Your job just sends its row count with a ping.
Free plan with 5 checks, no card needed. No database credentials, ever.
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 does that comparison for you. It keeps each job's history and compares every run with the same weekday in recent weeks, 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.
One week, two ways to watch it
| Night | Rows loaded | Fixed rule: alert if under 20,000 | normbeat: compare with the same weekday |
|---|---|---|---|
| Mon | Rows: 48,200 | Fixed rule: quiet | normbeat: normal for a Monday |
| Tue | Rows: 47,100 | Fixed rule: quiet | normbeat: normal for a Tuesday |
| Wed | Rows: 46,800 | Fixed rule: quiet | normbeat: normal for a Wednesday |
| Thu | Rows: 31,400 | Fixed rule: quiet: misses it | normbeat: alert: Thursdays usually 45,000–50,000 |
| Fri | Rows: 47,900 | Fixed rule: quiet | normbeat: normal for a Friday |
| Sat | Rows: 9,800 | Fixed rule: alert: false alarm | normbeat: normal for a Saturday |
| Sun | Rows: 8,900 | Fixed rule: alert: false alarm | normbeat: normal for a Sunday |
The fixed rule pages you twice for a normal weekend and stays quiet when a third of Thursday's orders go missing. Illustrative numbers, not real data.
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 all work. A dedicated Airflow integration is planned.
-
Let it learn, get alerted when a run looks wrong
normbeat builds a normal range from that job's own runs. Learning a weekly pattern takes a few weeks of history. From the first run, you still get alerts for missed runs, late runs, failures and zero counts, and for counts below a minimum, if you set one for the check. Alerts go to email, Slack or Telegram, and each check keeps a run history with a small chart of the count over time.
fail if the load errors)#!/usr/bin/env bash
PING="https://ping.normbeat.com/p/YOUR_CHECK_KEY"
if rows=$(python3 load_orders.py); then
curl -fsS -m 10 "${PING}?rows=${rows}"
else
curl -fsS -m 10 "${PING}/fail"
exit 1
fi
pip install normbeatimport normbeat
# sends "start", then the count, or "fail" if the block raises
with normbeat.run("YOUR_CHECK_KEY") as r:
r.count(run_orders_load()) # your existing job, returns a row count
You decide what to count. normbeat never connects to your database. All it sees is the number your job sends. The Python client is open source (MIT) and has no dependencies.
If normbeat is down, your job still runs. The client never raises an error into your code: network problems are logged and skipped, with a 10-second timeout.
What a ping sends: the check key in the URL, whether the run started, succeeded or failed, and the count if you include one. normbeat records the time it arrived and, like any web request, sees your IP address. Nothing else leaves your network: no data, no hostnames, no credentials.
Six alerts. No thresholds required.
| 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. |
orders_load: far too low
312 rows · Sun 02:03 · exit 0
Sundays usually 3,800–4,500
(last 4 Sundays)
Last runs: 4,210 · 3,960 · 4,415 · 312
Every alert says what it expected and why, so you can tell at a glance whether it's real. Alerts go by email, Slack or Telegram. 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 does differently
- It works out the normal count for you. No rule to write, no number to pick. The range comes from the job's own history.
- It knows what day it is. A Saturday gets compared with other Saturdays. That's the case where fixed thresholds page you for nothing.
- It checks both sides. Far too low and suspiciously high, from the same learned range.
- It's built for data jobs. A Python client today, an 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 can run normbeat next to it, or use normbeat alone, since it also covers 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.
Pricing
Free
$0
- 5 checks
- Learned normal range for every check
- Email, Slack and Telegram alerts
- No card needed
Paid
$9.99 a month
- 25 checks
- Everything in Free
- Priced per account, not per user
- First 3 months free during the beta
Cancel any time from your account page. The trial needs a card but you're not charged until it ends. Prices in USD; local taxes are handled by our payment provider, Polar. No sales calls.
FAQ
How does it know what's normal for my job?
From the counts your job sends. It keeps a history per check and works 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 takes a few weeks of runs. Until then you still get alerts for zero counts, missed runs, late runs and failures, and you can set a minimum count per check that works from the first run.
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 learns the range for you and alerts on both too low and too high.
Do you need my database credentials?
No. normbeat never connects to your database, warehouse or bucket. Your job counts its own output and sends that number in the ping. That number is all normbeat sees.
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 can learn its pattern.
Is it open source?
The Python client that sends pings is open source (MIT), so you can read exactly what it sends. The hosted alerting is the paid part. You can also skip the client and use plain curl.
Can I use it now?
Yes. Enter your email on the sign-in page and you'll get a link that creates your account. The Free plan needs no card. normbeat is in beta, so Paid comes with the first 3 months free, and early users' feedback decides what gets built next.
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 is the tool I wanted for both problems.
Start free
Your first check takes about two minutes.
- Enter your email. You get a sign-in link; there's no password.
- Create a check and say when the job runs.
- Add the ping, with its row count, to the end of your job.
Free plan: 5 checks and every alert channel, no card needed. Questions or a story about bad data that got past you? Email hello@normbeat.com. I read every one.