Home › Topics › Polling Intervals & Data Granularity › Choosing Intervals

Choosing Polling Intervals: A Per-Metric Decision Guide


Every check in your monitoring system has a setting most admins never touch: how often it runs. The tool ships with a default — five minutes is a popular one — and that default quietly becomes the answer for everything. Ping checks, CPU graphs, disk space, certificate expiry dates: one interval, applied to metrics that could not be more different from each other.


The one-size interval fails in both directions at once. Pointed at slow-moving things, it wastes effort. Asking a disk "are you full yet?" every five minutes is like checking whether your hair needs a cut every five minutes. Pointed at fast-moving things, it blinds you. A five-minute gap between questions is an eternity for a link that just went down. The outage clock is running the whole time you are not asking.


This guide gives you a better way: one question that decides any metric's polling interval. It gives you five speed classes that cover almost everything you will ever monitor. And it includes a worked interval plan for a small network you can adapt in an afternoon. By the end, "how often should this check run?" stops being a shrug and becomes a thirty-second decision you can defend.


In this guide

  • The one question that decides every interval
  • The five speed classes of metrics
  • What too fast and too slow actually cost
  • Same metric, different speeds: tier-aware polling
  • Keeping intervals honest over time
  • A worked interval plan for a small network
  • Where to go next

The one question that decides every interval


First, the vocabulary, because three words do all the work here. Polling is your monitoring system asking a device a question on a schedule — "are you up?", "how busy is your CPU?", "how full is that disk?". The polling interval is the gap between questions. Each answer that comes back is a sample: one timestamped value stored in the monitoring database. A one-minute interval means sixty samples per hour per metric; a fifteen-minute interval means four. That is the whole mechanism.


Now the question. For each metric, ask: how fast can this value change in a way I care about, and how fast do I need to react when it does? Both halves matter. An interface can go from carrying traffic to dead in a millisecond. And you probably want to know within a minute — fast change, fast reaction, fast polling. A firmware version changes only when somebody changes it. Nobody is rebooting a switch at 2 AM because a version string moved — slow change, slow reaction, slow polling. And here is the half people forget. If the fastest anyone will ever respond to a lab switch alert is "tomorrow morning," then thirty-second polling on that switch buys you nothing except load. Reaction speed caps the useful polling speed.


To reason about the "how fast do I find out" half, you need one small piece of math, and it is genuinely small. A failure happens at a random moment between two polls. On average it happens halfway through the gap. So your average detection delay is half the polling interval, and your worst case is the full interval. Poll every 5 minutes and a crashed server waits, on average, 2.5 minutes just to be noticed — up to 5 if the timing is unlucky. Then confirmation logic adds more. If your alert rule sensibly requires two consecutive failed polls before it fires (to filter out one-off packet loss), add another full interval. A 5-minute check with 2-poll confirmation averages about 7.5 minutes from failure to alert, and can take 10. None of that is a bug; it is arithmetic, and it is the honest answer to "how quickly would we know?" The same math governs synthetic tests — scheduled fake-user transactions. The guide on choosing synthetic test frequency walks the same reasoning from that side.


The five speed classes of metrics


You do not need to run the question from scratch for every metric, because metrics cluster into a handful of speed classes. Learn the five classes and you can sort a new check into the right one on sight.


Class 1: Fast state — up/down facts (30–60 seconds where reaction is fast)

These are the yes/no questions: is the device answering pings, is the interface up, is the service alive, is the VPN tunnel established. The value can flip instantly, and when it flips on something important, the outage has already started. This is the one class where short intervals genuinely pay, because detection delay converts directly into user-facing downtime. At 60-second polling your average detection is 30 seconds. At 5-minute polling it is 2.5 minutes, plus confirmation either way. Reserve 30–60 second polling for up/down checks on devices where somebody will actually react quickly. That means the firewall, the core switch, and the servers everyone touches. For everything else, 2–5 minutes is still perfectly respectable.


Tip: resist the urge to poll state every 10 seconds because faster sounds safer. Below about 30 seconds you hit diminishing returns fast. You cannot react in 10 seconds anyway. Brief network hiccups start looking like outages, and the polled devices pay a real CPU cost for your vigilance. Speed you cannot act on is just load.


Class 2: Fast-moving numbers (1–5 minutes)

Interface utilization, CPU load, memory pressure, latency to key targets — numbers that can move meaningfully within a minute or two. You poll these at 1–5 minutes for two reasons. First, alerting: a saturated WAN link or a pegged firewall CPU is a now-problem, and you want the alert within minutes. Second, graph shape: at 1-minute resolution a traffic graph shows you the actual character of the load — the bursts, the ramp at 9 AM, the backup window. At 15 minutes the graph turns into gentle, uninformative hills. Use 1 minute on the boxes where shape and speed matter, 5 minutes where a trend line is all you need. Be aware that even 1-minute polling averages away sub-minute bursts. That blindness is real, measurable, and covered honestly in what your polling interval cannot see.


Class 3: Steady accumulators (5–15 minutes is plenty)

Disk usage is the star of this class: values that creep in one direction over hours and days. Outside of an incident, disks simply do not fill in seconds — a volume at 62% at breakfast will be somewhere near 62% at lunch. Polling it every minute produces sixty nearly identical samples per hour, which is effort spent proving the obvious. Every 5–15 minutes is plenty. "But what about the runaway log file that fills a disk in an hour?" Fair — and that incident case is caught not by faster polling but by a growth-rate alert. That is a rule that fires when usage climbs abnormally fast between samples. Even at 15-minute polling, a disk gaining two percentage points per sample gets flagged within half an hour, with plenty of disk left to act on. Same class: DHCP scope usage, mailbox database sizes, backup repository consumption.


Class 4: Slow facts (hourly or daily)

Firmware versions, certificate days-to-expiry, domain registration, license counts, RAID array membership, configuration serial numbers. These change rarely, and when they change, the useful reaction is measured in days, not minutes. Checking certificate expiry every five minutes does not make the certificate expire more politely. Once or twice a day is exactly as protective and thousands of times cheaper. Hourly is for slow facts where same-day awareness helps (a RAID member dropping out); daily is for the calendar-scale stuff.


Class 5: Events — the channel you do not poll at all

Some information should not be fetched on a schedule, because the device will volunteer it the moment it happens. SNMP traps and syslog messages are the event channel. The device interrupts you — "my power supply just failed," "that port just went down" — instead of waiting to be asked. This is the natural division of labor. Polls give you regular, reliable, trend-friendly samples and catch the failures a dead device can never announce. Events give you instant notice of the changes that happen between polls. Neither replaces the other. A trap can be lost in transit (it is fire-and-forget), so polling is your safety net. A poll can be minutes late, so events are your speed. Point traps and syslog at your monitoring system and let each channel do its job.


What too fast and too slow actually cost


Interval choices are a trade, and it helps to see both sides of the ledger in one place. Polling too fast has four costs. It burns device CPU. Answering SNMP queries is low-priority work on a switch's small management processor, and an aggressive poller can visibly load it. Fast polling burns poller capacity. Your monitoring server has a finite number of checks per second it can run. Every over-polled metric spends that budget. Fast polling burns storage: twice the polling rate means twice the samples, forever. And it raises noise sensitivity: the more often you sample, the more one-off wiggles you observe, and alert rules built on single samples get twitchy.


Polling too slow has two costs, and they are sneakier. The obvious one is detection lag — the interval/2 math above, applied to outages. The quieter one is baseline mush. A baseline is your recorded picture of what "normal" looks like, and coarse polling smears the peaks and valleys out of it. If you only sample a link every 15 minutes, its recorded "normal peak" is a rounded-off average. Then next month's genuinely abnormal spike gets compared against a flattering blur. Slow polling does not just delay bad news; it degrades your definition of normal.


What suffersWhen you poll too fastWhen you poll too slow
Polled devicesManagement CPU load on every cycle—
Monitoring serverMore checks/sec; cycles can overrun—
StorageSamples pile up at double or 5x rate—
Alert qualityTwitchier; sees every transient wiggleMisses or lags real events
Detection speed—Average delay = interval ÷ 2, plus confirmation
Baselines & graphs—Peaks smeared; "normal" becomes a blur

Notice the shape of the table: too-fast costs are paid in resources, too-slow costs are paid in knowledge. Resources are measurable and fixable; missing knowledge is invisible until the day you needed it. That asymmetry is why, when genuinely unsure, erring one notch faster on important metrics is the safer mistake. It is also why the next section exists, so you do not pay the fast price everywhere.


Same metric, different speeds: tier-aware polling


Here is the idea that makes the whole budget work: the same metric deserves different intervals on different devices. CPU load on the firewall that carries the entire office is a 1-minute metric — if it pegs, everyone feels it now. CPU load on the spare switch in the test rack is a 15-minute metric at best — if it pegs, a graph somewhere gets more interesting. Same OID, same check type, wildly different stakes.


Suppose you have tiered your devices: Tier 1 for business-stopping equipment, Tier 2 for important-but-survivable, Tier 3 for everything you monitor mostly for the records. Then intervals are one of the main things tiering is for. Tier 1 earns fast state checks at 30–60 seconds and fast numbers at 1 minute. Tier 2 runs a comfortable 2–5 minutes. Tier 3 idles along at 10–15 minutes, spending almost nothing and still building a usable history.


Two things to make peace with. First, this is not sloppy inconsistency — it is correct design, the monitoring equivalent of triage. Anyone who asks "why do these two switches poll at different rates?" should get a confident answer: "because one of them can take the company down." Second, do not over-engineer it: two or three speed bands cover a small network. If you find yourself maintaining seven bespoke interval schemes, you have invented a hobby, not a policy.


Keeping intervals honest over time


Set defaults per check class, then allow exceptions

Do not set intervals device by device from scratch; you will end up with sixty accidental one-off decisions nobody remembers. Most tools let you define a check once — as a template, a check class, a device role — and apply it broadly. Put the interval on the class ("all ping checks: 60 s", "all disk checks: 10 min") and override per device only where a tier demands it. That way your interval plan lives in a handful of visible settings instead of being smeared across the whole configuration.


Consistency is a feature: stable cadence makes data comparable

Whatever intervals you choose, changing them casually has a cost: comparability. Week-over-week comparisons, seasonal patterns, and baselines all assume the data was collected the same way throughout. A "normal Monday" recorded at 5-minute resolution is not directly comparable to this Monday recorded at 1 minute. The finer data will show peaks the older data smoothed away. A naive comparison reads that as "traffic got spikier" when only the sampling did. Baselining depends on steady cadence more than any other practice. The guide on collecting network baselines leans on exactly this property. Pick sensible intervals early, then leave them alone unless you have a reason.


When you do change an interval, change it deliberately

Reasons to change do come up: a device gets promoted to Tier 1, an investigation needs finer data, the poller needs relief. Make it a small ceremony rather than a silent tweak:

  • Write a change note — date, check class, old and new interval, reason. One line in your change log is enough.
  • Change one class at a time, and watch your poller's own load for a day before the next change.
  • Annotate the graphs if your tool supports marking events on charts, so future-you sees where the cadence shifted.
  • Re-read old comparisons skeptically across the boundary. Graphs change character when cadence changes. The change note is what stops someone from "discovering" a performance regression that is actually a settings change.

That last point is the classic misread. A link polled at 15 minutes shows serene rolling hills; repoll it at 1 minute and it shows jagged peaks brushing 90%. Nothing about the traffic changed — you just started looking closely enough to see what was always there. Without the note, that graph becomes a mystery ticket; with it, it is a sentence in a changelog.


A worked interval plan for a small network


Here is the whole method applied to a concrete small estate: about 60 devices. There is a firewall, a core switch, a dozen access switches, and three hypervisor hosts and their key VMs. There are a couple of dozen servers and appliances, Wi-Fi access points, a UPS, and the usual supporting cast. One master table, one afternoon of configuration:


Check classIntervalWhy this speed
Up/down: Tier 1 (firewall, core switch, key servers, UPS state)30–60 sDetection = interval ÷ 2; outage minutes here are felt by everyone
Up/down: Tier 2–3 (access switches, APs, minor servers)2–5 minStill noticed within minutes; nobody reacts faster for these anyway
Utilization, CPU, latency: Tier 1 paths1 minAlerting speed plus graph shape on the links that matter
Utilization, CPU: everything else5 minTrend quality without the load; shape rarely matters here
Disk usage, DHCP scopes, repository sizes10–15 minAccumulators creep; runaway growth is caught by a rate alert, not by fast polling
Certificate expiry, firmware, licensesDailyCalendar-speed facts; faster checks add zero protection
Traps and syslogNo scheduleEvent channel: the device reports the moment something changes

Read the table top to bottom and you can see the philosophy. Speed is concentrated where change is fast and reaction is fast, and everything else is deliberately, unapologetically slower. This plan runs a 60-device network on a modest fraction of the polling capacity that a flat 1-minute-everything plan would demand. This plan detects the outages that matter sooner than a flat 5-minute plan would.


Tip: when in doubt about a metric, start it one notch slower than your instinct says and let it earn a faster interval. It is easy to speed up a check that proves important. It is surprisingly hard to notice that you have been over-polling three hundred checks for two years.


Where to go next


The mental model to keep: polling speed is a budget, not a virtue. Every interval you shorten spends device CPU, poller capacity, and storage; every interval you lengthen spends detection speed and data quality. The skill is not polling fast. It is spending speed exactly where it pays: fast state on Tier 1, fast numbers on the critical path, and a calm, cheap cadence everywhere else.


Two natural next steps. To see what your polling actually costs, read the companion guide on the polling load budget. It covers packets, device CPU, and poller headroom, with the arithmetic made friendly. And to understand the other side of the bargain, see what your polling interval cannot see. It covers what happens in the gaps between your polls, and when that blindness matters. The rest of the Polling Intervals & Data Granularity pillar covers how this data ages and how long to keep it.


Put this into practice with SysPeep Monitor

An interval plan only helps if your tool makes it easy to apply. SysPeep Monitor auto-discovers your devices and interfaces. It collects health and performance metrics over SNMP, WMI and SSH. It pairs them with thresholds and alert rules designed to keep the noise down. The free trial installs on any Windows machine.

Download Free TrialLearn About SysPeep