The shop is reachable, checkout accepts orders, monitoring reports nothing -- and yet stock levels are wrong, orders are missing from the ERP system, and the price import has not written a single row since the weekend. This failure type is particularly expensive because it does not present itself as an outage: a background process stops without comment, and it only surfaces when a customer complains or accounting asks a question. 57 percent (Uptime Institute) of the operators surveyed put their most recent major outage at more than USD 100,000, and one in five (Uptime Institute) put it above a million. The stakes are correspondingly high: German online retail turned over 83.1 billion euros (bevh) in goods alone in 2025. This article shows how to monitor cron jobs, workers and imports so that their silence becomes the alert -- as a fixed element of continuous shop maintenance.
Key takeaways
- Uptime, checkout and log monitoring each answer their own question. None of them notices when a cron job quietly stops -- that requires a layer of its own.
- Background jobs rarely die loudly: the worker is killed after hitting a memory limit, a stale lock file stays behind, credentials change, or a run overtakes itself.
- Heartbeat monitoring inverts the logic: the alert is triggered not by an error but by a missing sign of life within an expected time window.
- Runtime and volume thresholds expose half-finished runs. An import that completes in twelve instead of sixty seconds and writes a third of the rows counts as technically successful.
- A silent failure costs twice over: oversold stock on one side, orders left untransferred on the other. For 57 percent (Uptime Institute) of the operators surveyed, the most recent major outage exceeded USD 100,000.
When the page stays green and money still goes missing
Most shops monitor three layers, and each answers a different question. Uptime monitoring asks: is the server responding? Checkout monitoring asks: can an order still be completed? Log analysis asks: is the application writing errors to its log files? All three layers are worthwhile, and all three share the same blind spot. They observe what happens. A failed background job, however, is defined precisely by the fact that nothing happens -- no request, no error code, frequently not even a line in the log. What is missing is the fourth question: did the thing that should run regularly actually run?
Economically this gap is no small matter. The damage to the German economy in 2025 from data theft, espionage and sabotage came to 289.2 billion euros (Bitkom), of which 202.4 billion euros (Bitkom) related to cyberattacks; 87 percent (Bitkom) of the companies surveyed reported incidents. Silent job failures do not appear in these figures, because they are usually not an attack but a plain operational fault. That is exactly what makes them stubborn: an attack has reporting chains, templates and insurance policies. For a cron job that has not run for eleven days, by contrast, nobody has often claimed responsibility -- all the attention sits on external threats while internal processes keep running unobserved, or do not.
What counts as a background job in this article
The usual candidates in shop operations
Before anything can be monitored, it has to be named. A shop that has grown over the years contains a surprisingly long list of processes working in the background -- set up by different people over the years, some in the server's task scheduler, some inside the shop system, some as a service on a second machine. The following nine groups typically cover the bulk of them. More important than the completeness of the list is the method: record every process in an inventory with its expected cadence, its purpose and a responsible person. Backups are a special case, since a run without a restore test says very little -- the criteria for that are covered in the article on backup strategies with RPO and RTO.
Inventory sync
The sync with the ERP system keeps available quantities current. If it stops, the shop keeps selling what ran out long ago -- the most expensive silent failure of all.
Price and product import
Supplier files, tiered prices, new articles and descriptions. A failed import freezes the catalogue at an old state without any message appearing anywhere.
Order export
Handing new orders over to the ERP system, shipping and accounting. If it stops, paid orders pile up that nobody picks and packs.
Feed generation
Product data feeds for advertising channels, price portals and marketplaces. A stale feed advertises prices and availability that no longer exist.
Invoice and dunning runs
Document creation, payment reconciliation and payment reminders. If the run stops, incoming payments slip and open items sit unnoticed.
Search index rebuild
The full-text index behind shop search. Once it stops, search misses new articles and keeps showing removed ones -- a quiet loss of revenue.
Cache warming
Pre-filling page and object caches after a deployment or import. Without it, the first traffic peak hits a cold application.
Backup run
The nightly backup of database and files. A backup job that quietly stops is often noticed only in an emergency -- the worst possible moment.
Certificate and housekeeping jobs
Automatic certificate renewal, clearing old sessions, removing temporary files. Unspectacular, until the disk fills up or a certificate expires.
Why background jobs die quietly
A job that aborts with a clear error is the pleasant case: it leaves a trace. The expensive cases are those where the system behaved correctly as far as it was concerned. The scheduler started what it was told to start; the fact that the result came back empty was not an event for it. Six patterns explain the bulk of the silent failures we encounter in practice -- and none of them reliably produces an entry that error monitoring could build on.
Memory limit kills the worker
An import run consumes more memory than permitted and the operating system terminates the process hard. A service without a restart rule then simply stays gone -- with no entry in the application log.
The lock file stays behind
Many jobs create a lock file so runs cannot overlap. If the process is killed abruptly, the lock remains, and every subsequent run exits immediately and without a sound.
Changed credentials
A password for the ERP system is renewed, an access key expires. Authentication fails, the job catches the error and exits with a success message.
Clock changes and time zones
A run scheduled for 2:30 a.m. either does not exist or happens twice on the night the clocks change. If the server sits in a different time zone than the business team, the window shifts further.
The run overtakes itself
As the catalogue grows, a five-minute job eventually takes seven minutes. From then on runs start while the previous one is still working -- until processes block each other or write data twice.
Success despite half a result
The remote system delivers an empty or truncated file, the import processes it dutifully and reports success. Technically that is correct. In business terms forty thousand rows are missing.
What all six patterns share is that classic error monitoring cannot see them. Anyone waiting solely for log entries at ERROR level waits in vain during a silent failure. The database behaves similarly: a job that runs into a timeout because of a blocking query sometimes leaves nothing but an entry in the slow query log -- a side effect that tidy database maintenance noticeably defuses.
An exit code of zero is not a business success message
Heartbeats instead of error messages
Heartbeat monitoring inverts the usual logic. Instead of waiting for an error message, it waits for a sign of life -- and raises an alert when it fails to arrive. After finishing its work, every job reports to a collection point: I ran, this is how long I took, this is how many records I processed. If that message stays away longer than the configured time window, an alert is raised. The principle comes from operating distributed systems; the operational practice established there sums up the basic observation metrics as the four golden signals (Google SRE): latency, traffic, errors and saturation. Background jobs add a fifth metric that is only implicit there: the absence of activity.
The time window is the actual design step. It should be generous enough to absorb normal variation and tight enough to keep the damage contained. A workable rule: the expected interval times two, plus the typical runtime. An order export running every ten minutes with a one-minute runtime therefore gets a window of roughly twenty-one minutes. Jobs with a direct financial impact get a tighter window, pure housekeeping a wider one. What matters is that the window is documented and justified -- otherwise the first false alarm pushes it to a value at which practically nothing reports any more.
# Every run reports duration and volume to our own monitoring
*/10 * * * * shopuser /usr/local/bin/order-export.sh
# order-export.sh (excerpt)
START=$(date +%s)
ROWS=$(php bin/console shop:export:orders --quiet --count)
DURATION=$(( $(date +%s) - START ))
curl -fsS -m 10 --retry 3 \
-d "job=order-export&duration=${DURATION}&rows=${ROWS}" \
https://monitoring.example.com/heartbeat/Alert on silence
Runtime and volume: thresholds against half-finished runs
A sign of life alone is not enough. The second most common silent failure is the run that takes place, reports in and is still wrong: the import processes nine hundred rows instead of forty thousand because the source file was truncated. The heartbeat arrives on schedule, no alert is raised, and the catalogue is unusable anyway. That is why every sign of life carries two additional metrics: the duration of the run and the volume it moved. Both are compared against a rolling average for the same hour of the week rather than a fixed value -- a Monday morning simply looks different from a Sunday night.
| Background job | Expected sign of life | Additional threshold |
|---|---|---|
| Inventory sync | every 15 minutes | changed articles below 20 percent of the average |
| Price and product import | hourly | runtime above twice the average |
| Order export | every 10 minutes | open orders older than 20 minutes |
| Feed generation | every 30 minutes | file size deviates by more than 20 percent |
| Invoice and dunning run | daily | documents created below the previous day's count |
| Backup run | daily | archive size plus a passed restore test |
The thresholds are allowed to be rough. This is not statistical fine work but a line between normal and obviously wrong. For a catalogue import a downward deviation of twenty percent is usually reason enough to take a look; eighty percent is an alert. The opposite direction matters just as much: an import that suddenly writes three times as many rows as usual points to a file read in twice, and produces duplicates that later have to be untangled by hand. How tightly the thresholds can sit before alert fatigue sets in is the same trade-off as in log monitoring and alerting.
Reading queues: length and age
Many shop systems no longer work with plain cron jobs but with queues: tasks are written to a list, and one or more workers pick them up and process them. That is more robust, but it only moves the problem one layer along. If no worker is available any more, the queue fills up silently -- the application keeps accepting tasks, not a single error is produced, and from the outside everything looks fine. Only the queue itself reveals the true state, through two metrics: its length and the age of the oldest waiting entry.
Of the two, age is the more meaningful metric. A long queue can be a healthy traffic peak that clears in ten minutes. An entry that has been waiting for forty minutes, by contrast, means with high probability that nobody is picking it up any more. That is why the alert threshold sits on age rather than on volume. It is also worth watching the dead-letter store: tasks that fail permanently after several attempts end up there and are rarely retrieved on their own. A counter on that store costs little and exposes a whole class of follow-on faults.
- Queue length per channel, separated into orders, mail, indexing and media
- Age of the oldest waiting entry in minutes, with an alert threshold of its own
- Number of retry attempts per task and the limit at which processing is abandoned
- Fill level of the dead-letter store and the age of the oldest entry in it
- Throughput per minute compared with the average for the same hour of the week
- Number of active worker processes against the configured target count
Responsibility and escalation outside office hours
An alert that nobody reads at 3:40 a.m. is a log line. The question of who responds when is therefore not an organisational afterthought but part of the design. Background jobs typically run at night because the load is low then -- which means they also fail at night. A nightly import failure handled only the following morning has by then produced half a selling day with wrong stock levels. A staged chain makes sense here, in which urgency decides the route and not every alert receives the same treatment.
The signal fails to arrive
The expected sign of life does not appear within the window. Monitoring flags the job as overdue and starts the pre-check instead of waking someone immediately.
Automatic pre-check
Within two minutes the system verifies whether the service is running, whether a lock file has been left behind and whether the server responds. A controlled restart resolves a share of the cases right here.
Alert to the on-call engineer
If the state persists, the alert goes to the person on duty with the job name, the last sign of life and the pre-check result -- via a channel that genuinely wakes someone at night.
Time-based escalation
If the alert is not accepted within the committed window, it moves to the next stage. Each stage is named, has a deputy and is recorded in the documentation.
The expected sign of life does not appear within the window. Monitoring flags the job as overdue and starts the pre-check instead of waking someone immediately.
Within two minutes the system verifies whether the service is running, whether a lock file has been left behind and whether the server responds. A controlled restart resolves a share of the cases right here.
If the state persists, the alert goes to the person on duty with the job name, the last sign of life and the pre-check result -- via a channel that genuinely wakes someone at night.
If the alert is not accepted within the committed window, it moves to the next stage. Each stage is named, has a deputy and is recorded in the documentation.
Which window is realistic depends on the business model. A shop with strong evening and night trade may well need a response time of thirty minutes; a trade-focused shop with orders during office hours is frequently fine with the next working day. What matters is that the window is committed and measurable -- which metrics need clean definitions for that is described in the article on response times in the SLA. For cases outside the agreed service hours, emergency support takes over with a call chain of its own.
What a silent failure actually costs
The damage calculation for silent faults is uncomfortable because it has two sides. On one side sits overselling: if the inventory sync stops, the shop sells articles that no longer exist. Each of those orders creates a cancellation, a refund, at least one email and frequently a goodwill gesture. On the other side sit the orders that did arrive but were not transferred: they are paid for, but nobody picks and packs them, and shipping slips by the duration of the failure plus the catch-up time. Roughly one in ten (Uptime Institute) operators rates their most recent major outage as serious or severe; silent job failures rarely reach those statistics even though they have the same effect. Both sides can be quantified in five steps.
- Determine the failure window: when did the last valid sign of life arrive, when was the failure noticed, when was it resolved?
- Count the transactions not transferred: orders that arrived within the window and only reached the ERP system afterwards.
- Identify overselling: articles that kept selling after the last valid sync even though stock was already exhausted.
- Apply follow-on costs: cancellation rate, refund fees, service time per case, discounts and the share of customers who do not return.
- Value the rework: hours for re-import, reconciliation, duplicate cleanup and correction, multiplied by the internal hourly rate.
Run that calculation for a mid-sized shop with forty orders a day and a twelve-hour failure and you quickly arrive at twenty affected orders, half a day of rework and a handful of annoyed customers. The pure loss of revenue is often the smaller item; rework and loss of trust are more expensive because both keep working beyond the incident itself. Anyone who wants to run the numbers for their own shop will find the methodology in the article on downtime cost per minute -- it transfers one to one to silent job failures.
On top of that comes a legal dimension that is easily overlooked. Under Section 5 (2) (UWG), the availability of goods counts among the material characteristics about which customers must not be misled -- an inventory sync that has been silent for days is therefore more than an operational problem. For order receipt, Section 312i (1) (BGB) requires immediate electronic confirmation; if mail delivery is stuck in a queue, that obligation becomes hard to meet. And Article 32 (GDPR) calls for measures that secure the availability and resilience of systems as well as rapid restoration after an incident -- a backup whose absence nobody notices does not typically satisfy that standard.
Job monitoring as a fixed maintenance element
Heartbeat monitoring is not a project that is set up once and then forgotten. Every new import, every new interface and every major update brings additional processes with it or changes existing cadences. Job monitoring therefore belongs in the same rhythm as updates, backups and continuous monitoring: an inventory that is kept current, a regular review of the mute and the overly talkative alerts, and a responsibility that holds during holidays too. In the SLA maintenance contract this becomes a committed service with a defined response time rather than a good intention. Trade keeps growing meanwhile -- nominal goods revenue growth of 3.8 percent (bevh and EHI Retail Institute) is expected for 2026, and with every percentage point the number of transactions affected by a silent hour rises.
Two transitions deserve particular attention. When the service provider changes, background jobs are typically the first thing lost, because they appear on no handover list -- what to watch out for is described in the article on taking over maintenance without shop downtime. And an agency looking after client projects needs an inventory that works across all tenants; how to organise that is shown in the article on white-label maintenance for agencies. In both cases the list of background jobs is precisely the document that is most often missing.
A background job that tells nobody anything is not a reliable process but a bet on the next look into the backend. Monitoring means turning silence into a signal.
It starts with an inventory: which cron jobs, scheduled tasks and workers run in your shop, at what cadence should they run, and when did each of them last deliver a valid business result? That list becomes the monitoring plan, with time windows, runtime and volume thresholds and an escalation chain that reaches someone at night as well. You can request this inventory without obligation -- as a first step towards processes that report in themselves before anyone else does.
Sources and Studies