Home › Topics › Polling Intervals & Data Granularity › Interval Blind Spots

What Your Polling Interval Cannot See


Your monitoring system does not watch the network. It glances at the network, on a schedule, and assumes nothing interesting happened between glances. That is what polling is: a question asked every minute or every five, with silence in between. And in that silence, anything can happen. A link can die and recover, a port can flap a dozen times, and traffic can slam into the ceiling and back off. All of it can leave no trace at all in your graphs, because nobody was asking at the time.


This is not a flaw in your tool, and it is not fixable by buying a better one that also polls. It is the built-in bargain of sampled monitoring, and most of the time it is a perfectly good bargain. But every admin eventually meets its sharp edge. A user swears the network died at 2:14 while the dashboard shows a serene green afternoon. A link averaging 30% suffers "impossible" slowness. An outage report claims four nines your polling could never actually verify.


This guide is the honest accounting. You will learn exactly what hides between polls, and why. You will meet the partial witnesses that see into the gaps even when polls cannot. You will learn where the blindness genuinely matters and where it genuinely does not. And you will learn how to describe your monitoring's abilities without promising things the math cannot deliver. Knowing your blind spots does not shrink them — but it changes what you claim, what you investigate, and whom you believe.


In this guide

  • Why the blindness is built in
  • The blind-spot catalog: four things that hide between polls
  • The partial witnesses: what sees into the gaps
  • Where blindness matters — and where it honestly does not
  • Claiming honestly: what an interval can promise
  • When users saw what monitoring did not
  • The honesty table

Why the blindness is built in


Think of polled monitoring as a film made of frames. A movie shot at 24 frames per second looks continuous. But between any two frames the actors could, in principle, do anything — the camera would never know. Polling is the same trick at a far slower shutter: one frame per minute, or one per five. Everything you "see" in a monitoring graph is reconstructed from those frames, with the gaps filled in by a polite assumption of continuity. The line between two samples is drawn straight, as if the world moved smoothly from one reading to the next.


Usually the world cooperates — most metrics most of the time really do move smoothly. The blind spots appear exactly when the world moves faster than the shutter: events shorter than one interval, or sequences of changes packed inside one gap. And notice that the smoothness itself is painted on. The straight line your graph draws between two samples is not data. It is interpolation — connective tissue the chart invents to be easy on the eye. Every pixel between two dots is an assumption wearing the same color as the facts.


Those are the cases this guide catalogs. Carry one number with you from the interval-choosing guide. On top of the gaps themselves, detection is late by half an interval on average even for events polling does catch. Blindness and lag are the two taxes every interval pays.


The blind-spot catalog: four things that hide between polls


1. Short outages: the three-minute blip

Take a real scenario: a device drops off the network for 3 minutes, and you poll it every 5. Whether you see anything at all is literally a matter of timing. If a poll happens to land inside the outage, you record one failed check. If the outage falls entirely between polls, you record nothing whatsoever. The intuition for the odds is simple. An event of duration D under an interval T gets noticed by at least one poll with probability of about D ÷ T (for events shorter than the interval). The 3-minute blip under 5-minute polling has a 60% chance of being glimpsed — and a 40% chance of never having officially happened.


Now add the twist most people miss: confirmation logic interacts with intervals. Sensible alerting does not fire on one failed poll. It waits for two or three consecutive failures to avoid paging you over a dropped packet. But two consecutive failed polls, 5 minutes apart, require the outage to span more than 5 minutes. A 3-minute outage can never satisfy that rule. At best it fails one poll. The next poll succeeds. And the "blip" is quietly dismissed as noise. The very mechanism that protects you from false alarms guarantees silence about real short outages. That is not a reason to remove confirmation — it earns its keep. But it means your effective detection floor is roughly the interval times the confirmation count. And you should know that number for your own rules. Tuning that trade-off between twitchiness and blindness is the home turf of the Threshold Tuning pillar.


2. Microbursts: saturation that averages into invisibility

Traffic metrics have a subtler blindness. Interface throughput is usually computed from counters — ever-growing tallies of bytes the device has sent. Each poll reads the counter, subtracts the previous reading, and divides by the gap: bytes over 5 minutes, presented as an average rate. The counter faithfully includes every byte of a burst — but smeared across the whole gap. Suppose a link idles around 20%, then slams to 100% for 30 seconds. That is long enough for queues to overflow, packets to drop, and video calls to stutter. Averaged over the 5-minute gap, those 30 seconds add just 30 ÷ 300, about 10 percentage points. Your graph shows a placid 30%. The users experienced a saturated link. The chart shows a Tuesday. Second-scale congestion — the microburst — is simply invisible to any polling interval a normal shop would run. That is because even 1-minute polling averages sixty seconds together. If graphs say "plenty of headroom" while users report brief freezes, believe the freezes and go look at drop counters (more on those below).


3. Flapping faster than the poll

A flapping port or tunnel — bouncing down and up over and over — can be the most disruptive thing on your network and still look immaculate in a status poll. Status is an instantaneous question: "up right now?" If the bounces last seconds and the recoveries land where your polls do, every glance finds the port up. In that case, the dashboard shows solid green through an afternoon of chaos. Each transition, meanwhile, was very real for users. Routing reconverged, sessions dropped, and spanning tree had feelings. The tells are indirect. Interface counters tick up (errors, carrier transitions where a device exposes them). A syslog channel fills with up/down messages. Users mutter that things keep "hiccuping." A green status history built from polls is evidence of nothing more than green moments.


Happily, flapping leaves fingerprints you can poll. Many devices expose a last-change timestamp per interface — ask for it. And a port whose "last change" keeps resetting is confessing to bounces no status poll witnessed. Where the device counts state transitions, the counter tells the same story in bulk. One extra polled value converts this whole blind spot into an alarm.


4. Sequence blindness: two changes in one gap

Polling records states, not stories. If two changes happen inside one gap, you see at most their net effect. And if something changed and changed back, you see nothing at all. The HA firewall pair that failed over and failed back between polls reports the same healthy primary at both glances. The fact that traffic took the scenic route for four minutes — and that your failover mechanism got exercised and maybe complained — is invisible. The same goes for the switch that rebooted quickly (uptime counters give it away at the next poll, if anything is watching them). It also goes for the config that was changed and hastily reverted, and the service that crashed and was auto-restarted. When two snapshots match, polling concludes "nothing happened." Sometimes a whole drama happened, symmetrically.


The partial witnesses: what sees into the gaps


The gaps are never fully dark, because polling is not the only channel you have. Three witnesses catch some of what the polls miss.


Counters: the device's accumulating memory

A counter is memory. Error counts, discard counts, byte tallies, uptime ticks — the device increments them the instant something happens and holds the total until you ask. The moment passes; the count remains. A burst that dropped 40,000 packets at 2:14 shows up in the discard counter delta at the 2:15 poll, even though no poll witnessed the burst itself. This is why counter deltas beat instantaneous gauges for catching short events. A gauge ("current queue depth") reports whatever is true during your glance. A counter ("total drops") sums everything that happened since your last one. It costs nothing to use this. Poll the error and discard counters on links that matter. Alert when deltas jump. You have converted pure blindness into "something happened in this five-minute window, go look." You lose the exact timing and shape, but you keep the fact — and the fact is what opens investigations.


Traps and logs: the event channel

The second witness fixes the timing problem: let the device tell you the moment something happens. SNMP traps and syslog messages are pushed by the device at the instant of the event. A port goes down at 2:14:07 and the trap says so at 2:14:07, mid-gap, no poll required. This is the standard remedy for interval blindness. It is a pairing, not a replacement. The polls provide the regular heartbeat that catches silent deaths (a dead device sends no traps — ever, about anything, including its own death). The events provide the between-polls eyes. Traps travel fire-and-forget and can be lost, which is exactly why the polling safety net stays. Consider a shop with 5-minute polling plus traps and syslog flowing into the monitoring system. It has far sharper effective vision than a shop with 1-minute polling and no event channel — at a fraction of the load.


On-change telemetry: the streaming answer

The modern endgame, where equipment supports it, is streaming telemetry. Instead of answering questions on your schedule, the device pushes readings continuously or the moment they change. With on-change subscription for state and second-scale streams for counters, the gap problem largely dissolves. The cost is newer gear, new collectors, and a data firehose to manage. For the handful of places that genuinely need second-scale truth it is the right tool. The guide to streaming telemetry explained covers when the upgrade earns its complexity.


Where blindness matters — and where it honestly does not


Here is the paragraph that keeps this whole subject calm: for most metrics, on most devices, the blindness costs you nothing. Capacity planning does not care that a disk's fill level went unobserved for fourteen minutes. Health trends, baselines, utilization reports, temperature curves — these are questions about sustained behavior, and sampled data answers them perfectly. A missed three-minute blip on a lab switch is not a monitoring failure. It is the system working as designed, ignoring what you decided (correctly) not to pay attention to.


Blindness matters in exactly two places. First, Tier-1 fast-reaction checks: where minutes of outage are minutes of business pain, short intervals plus an event channel are what buy you real detection. This is where you spend resolution, per the allocation logic in choosing polling intervals. Second, forensic needs: links and services where you must be able to reconstruct what happened — the WAN link under an availability agreement, the path behind user-facing latency complaints. There, counter deltas, traps, and (where justified) streaming close the gaps. Everywhere else, let the gaps be gaps and spend the savings where it pays.


Claiming honestly: what an interval can promise


Now the stakeholder conversation. When you tell a manager "we monitor that system at 5-minute resolution," here is what the math lets that sentence promise. Any outage longer than about ten minutes will be reliably detected (two consecutive failed polls), typically within about seven or eight minutes of starting. Shorter outages will often be glimpsed but cannot be guaranteed. Second-scale events are invisible except through counters and traps. The sentence must never be inflated into: "we would know within five minutes" (average detection is 2.5 minutes plus confirmation for the events you catch at all). Nor can it mean "nothing happened last night, the graphs are clean" (the graphs are clean about what the graphs measured, at the moments they measured it).


The same honesty applies to performance claims. "Latency averaged 20 ms" means "the samples we took averaged 20 ms". A five-minute ping check takes a few hundred glances a day at a link carrying millions of packets. That average is a fair summary of typical conditions and a poor witness to brief misery. Quote it as the former, never as proof of the latter.


Never claim detection faster than interval math supports, and never present absence of evidence as evidence of absence to someone making decisions on it. This costs you nothing in practice — stakeholders handle "outages over ten minutes: guaranteed; under three: best effort" just fine. What they do not handle well is discovering, mid-incident, that the dashboard's confidence was cosmetic. Honesty about resolution is cheap on Tuesday and priceless during the postmortem.


Tip: write the claim down next to the check. A one-line note like "5-min poll, 2-poll confirm: guarantees detection of outages >10 min" turns every future "why didn't monitoring catch this?" conversation into a ten-second answer. That note also tells you instantly when a requirement ("we must know within 2 minutes") needs a faster check rather than an apology.


When users saw what monitoring did not


Sooner or later a user reports something your monitoring flatly denies: "the network died for a couple of minutes around 2:15" versus an unbroken green line. Armed with this guide, your first move is different from most admins': believe the user. A 2-minute outage under 5-minute polling with confirmation is precisely the event your system is designed not to alert on. The system also has a healthy chance of not recording it at all. The user is not confused; your shutter was closed.


Then run the gap protocol:

  • 1. Check the witnesses, not the graphs. Counter deltas around the window (errors, discards, carrier transitions), traps, syslog, device uptimes. The polls glanced away, but memory and events may have caught it.
  • 2. Explain the gap honestly. "Our polling would miss an event that short" is a good sentence to say out loud. It builds more trust than a shrug at a green dashboard, and it correctly frames what happens next.
  • 3. Stake out the scene. If it might recur, temporarily crank that one check's cadence — 5 minutes down to 30 seconds, plus fast polling of the relevant error counters. Keep that up for a few days. This is the monitoring equivalent of a camera trap: cheap, targeted, temporary. The load cost of one fast check is trivial; only fleets of them need budgeting.
  • 4. Stand down afterward. When the culprit is caught (or the stakeout goes quiet), restore the normal interval and note what you learned. Permanent 30-second polling of everything is not the lesson.

The honesty table


One table to summarize what each common interval choice can honestly claim for up/down detection, assuming the usual two-poll confirmation. Halve the interval, halve the blindness; the shape never changes.


Polling intervalReliably detectsOften glimpsesCannot promise
30 sOutages > ~1 min, in ~1 minBlips of 15–60 sSecond-scale events; bursts
1 minOutages > ~2 min, in ~2 minBlips of 30 s–2 minSub-30 s anything
5 minOutages > ~10 min, in ~8 minBlips of 2–5 minShort blips; exact timings
15 minOutages > ~30 minEvents of 5–15 minAnything brief, entirely

Pair whatever row you choose with counters and an event channel, and you get most of the missing truth back for almost no load. That pairing — polls for the heartbeat, events for the gaps, resolution spent only where it pays — is the mature answer to interval blindness. The rest of the Polling Intervals & Data Granularity pillar covers its remaining pieces: what polling costs, and how long the samples you do collect survive.


Put this into practice with SysPeep Monitor

Closing blind spots is mostly about pairing channels: scheduled checks for the heartbeat, device-sent events for the gaps. SysPeep Monitor collects metrics over SNMP, WMI and SSH. Its thresholds, dependencies and alert rules are built to flag real trouble without drowning you in noise. Try it free on any Windows machine.

Download Free TrialLearn About SysPeep