Silence is not health
The most dangerous output an automated system can produce is a clean one. What I learnt when every scheduled job I relied on died quietly, and the checks I now use to tell 'nothing to do' from 'nothing worked'.

Earlier this year I discovered that every scheduled job I relied on to run my working week had been dead for 24 days.
Nothing had alerted. Nobody had complained. The morning summaries had stopped, the overnight syncs had stopped, the weekly review had stopped, and for more than three weeks I took the quiet as good news.
The reason was simple and slightly embarrassing. Most of those jobs were designed to stay silent when there was nothing worth saying. “Nothing to report” was the success message. So a job that had stopped running and a job that had run and found nothing looked exactly the same from where I was sitting.
I have spent most of my career building systems that alert on errors. This was a lesson in how little that protects you from absence.
Success-shaped failure
Once I started looking, I found the same pattern everywhere. A system fails, and the failure looks exactly like success. I now call these success-shaped failures, and they are far more common than the noisy kind.
A few that I have met in the past year:
- The empty list that was really an expired token. A search made with stale credentials came back with HTTP 200 and an empty result. To everything downstream, that read as “the queue is clear”. An empty result and a broken query can be the same bytes.
- The filter that quietly dropped the unlabelled. A query along the lines of “everything where the label is not X” skipped every item that had no label at all. The items most in need of attention were the ones that could never appear in the list.
- The test suite that passed with nothing in it. A pipeline went green because the test runner found zero tests and reported zero failures. A larger suite with hundreds of tests turned out to exercise about a fifth of the routes it was supposed to cover. Green tells you that nothing failed. It does not tell you that anything ran.
- The document that certified the past. A generated reference page rebuilt successfully against an out-of-date source. A stale document that says “updated today” is worse than no document, because it carries authority it has not earned.
None of these threw an error. All of them produced confident, wrong answers.
Why teams miss it
We instrument what we can imagine going wrong, and we imagine things breaking loudly. Exceptions, timeouts and 500s are easy to count. Absence is not an event, so there is nothing to count.
Automation makes this worse in a specific way. The whole point of a well-run routine is that you stop thinking about it. The better it behaves for the first few months, the less anyone checks it, and the longer a quiet failure can run. Dashboards add to the problem, because a tidy dashboard built on a dead feed looks every bit as authoritative as one built on a live one.
AI agents raise the stakes again. The more you let software act on your behalf, the more of your picture of the world comes from its output. If that output can be silently empty, the agent’s autonomy is only as good as your ability to notice when it has stopped.
The checks I use now
None of these is clever. Each one exists because its absence cost me something.
1. Check liveness from one inventory. Every scheduled job is listed in a single registry with its schedule, its owner, the output it writes and how stale that output may get before it counts as overdue. A liveness check reads that registry and reports anything that has not produced fresh output in time. The important detail is that the check reads the registry rather than its own hard-coded list. My first version had a hard-coded list, and a job added later went silent for eight days because the checker did not know it existed.
2. Make the numbers add up two ways. If a process claims to have handled a set of items, the handled items plus the skipped items should equal the total, and the total should be counted independently. This is the only check I have found that reliably separates “there was nothing to do” from “nothing worked”. When the sum does not balance, something fell through a gap you did not know was there.
3. Make empty results prove themselves. When a query comes back empty, run a cheap call that must return something, such as a known record or the identity of the account making the request. If that also fails, the empty result was an outage, not good news.
4. Treat zero as a failure where zero is implausible. A test run with no tests fails. A nightly import of zero rows fails. A weekly report with no entries is flagged rather than sent as “all clear”. It is better to be woken by a false alarm than reassured by a false green.
5. Stamp every derived view with its age. Anything built from a cache, an export or another job’s output says when it was last rebuilt. Past a threshold (I use 72 hours for most things) it is presented as stale, not current. The point is to make freshness visible to the reader, so they do not have to trust that someone else checked.
A control is only as good as its silence
The deeper lesson for me was about what a control actually is. A check that only speaks when something goes wrong is half a control. The other half is knowing that the check itself is still running, still looking at the right things, and still able to see what it is supposed to see.
The same logic applies well beyond scheduled jobs. A code review gate that a bot has quietly stopped performing is no gate. A security fix marked “done” in a tracker but never deployed is no fix. In each case the system was quiet, and quiet was read as fine.
So here is the rule I now hold myself to: if a system cannot tell the difference between “nothing to do” and “nothing worked”, it has not told you anything at all.