Incidents

How proactive monitoring stops small bugs becoming major incidents

Read enough postmortems and the pattern is unmistakable: almost no incident began as an incident. It began as something small, visible, and ignorable — and then it was ignored.

An escalation chain being cut at an early link

Most major incidents are the final stage of an escalation chain: a small error appears, repeats, compounds into degradation, degradation becomes failure, and failure becomes customer impact. Each link takes time — minutes to days — and each link is detectable. Proactive monitoring exists to interrupt the chain at its earliest, cheapest link, where the response is a routine investigation instead of an emergency. The economics are stark: the same root cause costs an engineer-hour at link one and a postmortem, an apology and churn at link five.

Key takeaways
  • Incidents escalate into existence: small error → repeated error → degradation → failure → customer impact, each link buying time to act.
  • Every link emits a detectable signal — the chain is only invisible to teams not instrumented to see its early links.
  • Cost grows multiplicatively along the chain; detection at link one or two converts emergencies into scheduled work.
  • The chain is where alert philosophy matters: early links deserve warnings in working hours, not 3am pages — or they get muted and the chain runs free.
  • Post-incident, the question that improves the system: which link did we catch it at, and what would have caught it one earlier?

The escalation chain, link by link

The canonical path from nothing to postmortem:

  1. The small error. A deploy introduces a bug that fails under a specific condition — an input shape, a browser, a locale. First failures occur within hours. Blast radius: a handful of users, mostly retrying successfully. Signal: a new error fingerprint appearing in collection; a first blip on one endpoint.
  2. The repetition. The condition recurs — it was never rare, just unlucky-first. Failures become a rate: dozens an hour. Signal: error count at multiples of the site's baseline; an endpoint's error rate deviating hard from its history. Still invisible to uptime; still cheap to fix.
  3. The compounding. Failures interact with the system: retries multiply load, queues back up, a connection pool starts starving, latency climbs for everyone, not just the affected condition. Signal: latency trending against baseline across hours; timeout onset; error budget burn accelerating. This is the last quiet link.
  4. The failure. A resource exhausts. The endpoint — or the service behind several endpoints — stops answering usefully. Uptime checks finally notice. Signal: everything at once; this is where reactive monitoring joins the story, at link four of five.
  5. The impact. Users cannot complete the thing they came for; support lights up; the incident becomes commercial. The postmortem will note, correctly, that the error fingerprint from link one had been present for four days.

The chain's defining property is that time between links is opportunity: hours to days in which the problem is real, observable, and dramatically cheaper than it is about to become.

The multiplication table of neglect

Attach rough costs to each link and the argument makes itself:

The multiplier between link one and link five is routinely two orders of magnitude. No other reliability investment buys cost reduction at that ratio, because no other investment gets to act before the expensive part.

What interruption requires, per link

Interrupting early needs the early links to be visible and credible:

The practice that closes the loop

Tooling makes the chain visible; a small practice makes the visibility compound. After every incident, ask the chain question: which link did we catch this at, and what signal would have caught it one link earlier? The answer is almost always specific — a fingerprint that existed on day one, an endpoint that deserved its own check, a trend that deserved a warning — and it becomes next sprint's monitoring change.

Teams that run this loop for a few quarters watch their incident distribution migrate leftward: fewer link-four surprises, more link-two investigations, and a growing file of would-have-been incidents that are now just tickets titled "investigated the warning, fixed the pool sizing". The major incident stops being a periodic certainty and becomes what it always technically was: a chain of small, catchable things — caught.

Most chains start with a change — correlating deploys with incidents is how to see the first link.

Quick reference

The chainSmall error → repeated error → degradation → failure → customer impact
Time between linksMinutes to days — every link is an opportunity to act cheaply
Cost multiplierRoutinely ~100× between link-one investigation and link-five incident
Link 1–2 detectorsError fingerprinting (new signature after deploy), rate deviation vs own baseline
Link 3 detectorsLatency trend against baseline, timeout onset, accelerating budget burn
Credibility ruleEarly links get working-hours warnings, never 3am pages — or the system gets muted
The learning questionWhich link did we catch it at — and what would have caught it one earlier?

Frequently asked questions

How do small bugs become major incidents?

Through an escalation chain: a bug fails under a specific condition (small error), the condition recurs (repeated error), failures interact with the system — retries multiplying load, pools starving — producing degradation for everyone, degradation exhausts a resource into outright failure, and failure becomes customer impact. Each stage takes time, which is why early detection has room to work.

Why do teams miss the early stages of incidents?

Because the early links emit signals most setups don't watch: a new error fingerprint, an error rate at multiples of its own baseline, latency trending upward while everything still "works". Uptime checks join the story only at outright failure — link four of five — and by then the cheap intervention window has closed.

What monitoring catches problems at the earliest stage?

Error collection with fingerprint grouping catches new failure signatures within minutes of a deploy introducing them. Baseline-deviation detection catches abnormal rates while absolute numbers are still small. Trend detection on latency and error-budget burn catches the compounding phase. Together they cover links one through three — the stages where a fix is an hour's work.

Why shouldn't early warnings page people at night?

Because credibility is what keeps early detection alive. An early-link anomaly is a working-hours investigation, not an emergency; paging at 3am for it teaches the team to mute the system, after which the chain escalates unobserved. Severity honesty — only genuine emergencies interrupt — is a functional requirement of proactive monitoring, not politeness.

How should teams learn from incidents they didn't catch early?

With one standing postmortem question: which link of the escalation chain did we detect this at, and what specific signal would have caught it one link earlier? The answer — a missing error collector, an unchecked endpoint, an un-alerted trend — becomes a concrete monitoring improvement, and repeated application migrates the team's incident distribution toward early, cheap catches.

Can every incident be caught early?

No — some failures skip the chain entirely and arrive at link four with no prodrome: sudden infrastructure loss, instantly-fatal changes. Honest proactive practice targets the majority that do escalate gradually, while keeping fast reactive detection for the rest. The goal is shifting the distribution, not achieving a myth of zero incidents.

How Merik handles it

Merik is built as a chain-interruption system. Link one: merik.js reports new error fingerprints minutes after a deploy ships them, and GitHub/Vercel webhooks put the deploy right beside the spike. Link two: every rate is judged against that monitor's own 14-day baseline, with floors and confirmation so small numbers stay honest. Link three: trend detection on latency and error-budget burn — the compounding phase — feeds an early warning carrying risk, confidence and every contributing signal.

The credibility rules are structural: one warning per asset, one alert per incident, and only budget-burn emergencies may interrupt outside working hours — early links arrive as calm briefings, which is why they stay unmuted. And the learning loop is recorded for you: warnings link to the incidents they predicted, incidents carry the timeline of what preceded them, so "what would have caught this earlier?" has an answer in the data. The chain still starts sometimes; it just rarely gets to finish.

Create your workspace →

Or talk to us about your team →