Home › Topics › Monitoring Your ISP & Holding Them Accountable › Measuring Your Circuit Yourself

Measuring Your Circuit Yourself: Trust, but Verify


Somewhere in your building a cable crosses a line you cannot see. On your side of it are your router, your switches, and your problems. On the far side is the circuit you rent from an internet service provider (ISP). For most businesses everything anyone knows about that circuit comes from one place: the provider's own status portal. I have sat in the meeting where the portal said green and the office said otherwise. The portal won, because it was the only instrument in the room.


This guide is about getting a second instrument. Not because your provider is dishonest; most are not. Their gauges point at their own network, average away the events that hurt you, and define "outage" in ways that suit the scorecard. By the end you will know what to measure continuously on every circuit you pay for, and where the measuring has to happen. You will know how to sample throughput without becoming your own outage, and why the monitoring must never depend on the thing it is judging.


One boundary before we start. This is the ongoing program: the quiet record-keeping you do between fires. A circuit may be misbehaving right now, and you need to prove whose side of the line the fault is on. That is an isolation exercise, and testing and escalating with evidence walks through it step by step. The program below is what makes that incident go fast, because the "normal" you compare against already exists.


In this guide

  • Why the provider's portal is not your source of truth
  • The measurement set: what to record continuously
  • Probe placement: inside your edge, testing through the circuit
  • Reading the two tiers together
  • Throughput samples without hurting production
  • Independence: don't let monitoring ride the circuit it judges
  • Building the per-circuit record
  • A starter plan for one circuit

Why the provider's portal is not your source of truth


Start with how the provider's numbers are made, because the problem is structural, not moral. When a portal reports your circuit's availability, that figure is usually computed from the provider's ticket system and their own polling. That means an outage frequently "begins" when a ticket is opened and "ends" when a technician closes it. The four-minute drop at lunch that nobody reported? It never happened, as far as that number is concerned. The provider is measuring its own performance against a definition of failure it also wrote.


The second problem is vantage point. The provider measures their network from inside their network: from their core out to, at best, the piece of equipment terminating your service. A portal cheerfully showing "line status: OK" is telling you that their box answers them. It says nothing about what a user on your side experiences when packets actually try to cross the line under load. Their view stops at their edge; your users live past it.


Third: resolution and retention. Portal graphs are often built from coarse samples or long averages, and an average is where short outages go to disappear. A three-minute failure vanishes inside a fifteen-minute average like a pebble in porridge. History may only be viewable for a limited window, may not be exportable, and is held by the party you would be disputing with.


And fourth, the definitions themselves bend toward the house. Time inside announced maintenance windows typically does not count against availability at all. Degraded-but-technically-up states — heavy loss, latency through the roof — often count as up. Figures may be averaged across a month or across many customers' circuits, so any one bad day is diluted to nothing. None of this is a scandal; it is just the wrong instrument for accountability. The portal is the provider's dashboard about the provider's network. You need your own dashboard about your experience of it. That means measurements you control, at a resolution you choose, under definitions you wrote down, retained for as long as the argument might last.


The measurement set: what to record continuously


Independent measurement does not mean measuring everything. Four kinds of numbers, recorded continuously per circuit, cover nearly every conversation you will ever need to have with a provider. Here is the vocabulary. A probe is a small automated test — typically a ping, the network's "are you there?" message — repeated on a schedule. And latency is how long the round trip takes. And packet loss is the percentage of probes that never come back. And availability is the fraction of time the circuit answered at all.


First, availability as you experienced it. A probe every minute, around the clock, through the circuit. From those answers your monitoring computes an uptime number that is yours: your clock, your definition, no ticket required for an outage to count. This single, boring check is the backbone of the whole accountability program. Set it up today. Not after the router upgrade. Today.


Second, latency and loss to a target just past the demarc. The demarcation point — the demarc — is where the provider's responsibility ends and yours begins, usually at their terminating equipment on your wall. The natural target just beyond it is the provider gateway: the first address on their side, which your router learned when the service came up. Probing it exercises the access line and almost nothing else, so trouble here points hard at the circuit itself.


Third, latency and loss to stable external anchors. An anchor is a well-known, well-run public service that is effectively always up. The classic choices are two large public DNS (Domain Name System, the service that turns names into addresses) resolvers operated by different organizations. Anchors represent the journey your users actually take: across the circuit, through the provider's network, out to the internet. The two tiers together are the diagnostic pair. Loss to the gateway and the anchors implicates the line. A clean gateway but lossy anchors points deeper into the provider's network or beyond.


Fourth, periodic throughput samples are short, scheduled tests of how much data the circuit actually carries. They get their own section below because they are the one measurement that can hurt you. If real-time audio and video matter to your business, add jitter (the variation in latency between probes) to the set. Jitter falls out of the same probes for free in most tools.


What to measureToward whatHow oftenWhat it proves
AvailabilityProvider gatewayEvery minuteThe circuit was up — by your clock, not their tickets
Latency + lossProvider gatewayEvery minuteHealth of the access line itself
Latency + lossTwo external anchorsEvery minuteThe real-world path your users ride
Throughput sampleA test target you choseScheduled, off-hoursDelivered rate vs. what you ordered, as a trend

You may want the deeper story on what each of these metrics means on a wide area network (WAN) line and what healthy graphs look like. If so, WAN circuit health covers the five numbers that describe a line. This guide leans on those definitions rather than repeating them.


Probe placement: inside your edge, testing through the circuit


Where the probes run from matters as much as where they aim. The rule: the probe lives inside your edge — on your side of the demarc, on your local network, typically on your monitoring server. It tests through the circuit, out toward the gateway and the anchors. That placement makes the measurement mean something. When a probe from inside fails, the failure happened somewhere along the path your users actually depend on. The two-tier targeting tells you roughly where that failure happened.


Two placements to avoid. Measuring only at the interface — reading your router's WAN port counters — tells you what crossed the port. But a port can be "up" with the line behind it in ruins. And measuring from outside in — a cloud checker pinging your public address — tests a different direction along a path you do not control. It blends in every network between that checker and you. It goes blind if your address stops answering pings for unrelated reasons. Outside-in checks are a useful second opinion. They are not your source of truth either.


Two honest caveats. If you run more than one circuit, each circuit's probes must be forced out through that circuit. Otherwise your failover routing quietly sends every probe down the healthy line and your graphs describe a circuit nobody is testing. The guide to multi-WAN visibility covers the mechanics. And gateways answer pings with their spare attention. Routers protect themselves by deprioritizing ping replies when busy. So a little wobble toward the gateway while the anchors stay clean is usually the gateway being coy, not the line failing. Patterns across both tiers are evidence; a single twitchy target is not.


Reading the two tiers together


The gateway-and-anchors pairing pays off the day something goes wrong, because the two graphs side by side localize trouble before you have touched a cable. Loss on both tiers, starting at the same minute, points at the access line between you and the provider. Everything past the gateway inherits the line's problems. A clean gateway with lossy anchors says the line is fine and the trouble lives deeper: inside the provider's network or out on the wider internet. Both tiers clean while users still complain? The circuit is innocent, and your attention belongs inside your own LAN. And one anchor suffering while the other stays clean usually means that anchor, or the path to it, has a problem of its own. That is exactly why you run two, operated by different organizations.


Treat these readings as a compass, not a verdict. When the compass points at the provider and money or credibility is on the line, the full isolation procedure turns suspicion into proof. That means bypassing your own equipment and testing at the demarc. And the incident-side guide owns that playbook. The continuous record's job is humbler and, over a year of small mysteries, larger: every reading comes pre-labeled with a suspect.


Throughput samples without hurting production


Availability, latency, and loss probes are feathers — a few packets a minute that no circuit will ever notice. Throughput testing is different in kind: to find out how much the pipe carries, you fill the pipe. Run a full-rate test at ten on a weekday morning and for that minute you are the incident. Calls stutter, the cloud crawls, and somewhere a ticket is born with your name secretly on it.


So throughput gets measured with etiquette. Schedule short samples — seconds to a minute — outside business hours, at a consistent time so results are comparable night to night. Aim them at a target built for the job: a test service made for the purpose, or better, an endpoint you control at another site. Do not hammer some third-party server at high frequency, and think twice on any circuit with a usage cap. A cellular backup line counts every nightly test against that cap.


Interpret the results with humility. A single test reflects the test server's own load and the tide of evening traffic on shared access media. It reflects a dozen other things that are not your provider. What matters is the trend. Suppose a circuit sampled near its ordered rate for months and now consistently delivers a fraction of it. That circuit is saying something no single test can say. Record the ordered rate from your service order next to the samples, so the graph and the promise sit in the same frame. And if a formal dispute ever needs a rigorous demonstration, that is the moment to arrange a proper test window with the provider. Do that rather than lean on midnight samples. There is more on that in escalating with data.


Tip: when a throughput sample looks terrible, check what else was using the circuit at test time before blaming anyone. Backups love the same quiet hours you picked for testing, and a speed test racing a backup job measures the fight, not the line.


Independence: don't let monitoring ride the circuit it judges


This is the failure that embarrasses good admins, and I know because it embarrassed me. The circuit died at two in the morning. The monitoring noticed within a minute and recorded the outage faithfully. Then it composed an alert email and handed it to a mail server that reached the world through the dead circuit. The alarm rang perfectly in a room nobody was in, and I found out at eight, from a user. A smoke detector that phones the fire brigade through the burning building is not a safety system; it is decoration.


The principle: measure through the circuit, alert around it. The probes must ride the circuit — that is the whole point. But the news of a failure needs at least one path that does not. Here are practical options, roughly in order of effort. Send alerts out a second circuit if you have one. Or give the monitoring server a small cellular modem as an alert-only back door. Or use a dead-man's switch — an external watcher, outside your network. It expects a periodic "all is well" signal from your monitoring and raises the alarm when the silence itself becomes the message. Even the humble version — a daily heartbeat whose absence you would notice — beats nothing.


Independence has a data half, too. The measurements must survive the outage to become evidence. So they belong on storage inside your building — not in a cloud dashboard you can only reach through the circuit that just failed. Local collection, local storage, independent alerting: the monitoring outlives the thing it watches.


Building the per-circuit record


Continuous measurement earns its keep when it accumulates into something you can put in front of another human. For every circuit, keep one record — a page in your documentation system is plenty. It has three layers: identity, rollups, and pointers to the raw graphs. The identity layer is the boring gold. It holds the circuit ID from the invoice (support desks navigate by it, not by your company name). It holds where the demarc physically is, the handoff type, the gateway address your probes target, and the rate on the order form. A skeleton worth stealing:


CIRCUIT RECORD — <circuit ID from invoice>
Site / demarc location:   <building, room, wall>  (photo on file)
Handoff:                  <copper / fiber / wireless> into <your edge device>
Provider gateway:         <first-hop address>   Ordered rate: <down / up>
Probes:  gateway 1/min | anchors A+B 1/min | throughput nightly
Monthly rollup:
  month | avail % | median ms | p95 ms | loss % | tput sample | notes
  ------+---------+-----------+--------+--------+-------------+------
        |         |           |        |        |             |

The rollup line is a five-minute monthly ritual. Read your own dashboards and write down availability as your probes saw it. Write down typical and worst-case latency (the p95 — the value 95 percent of samples beat — catches the bad moments an average hides). Write down loss and the throughput sample range. A dozen rows of this table is a service history no portal will ever hand you. That history slots directly into two other pieces of the program. The promises you compare it against live in reading your SLA. The incident-by-incident detail belongs in the circuit evidence file.


Mind your retention settings while you are here. Monitoring systems compress old data into averages to save space — sensible, except that averaging is exactly how short outages get erased. Keep fine-grained data long enough to cover a billing cycle and a dispute, and export graphs of anything interesting before the compression reaches it.


Meridian Parts had per-minute probes on its main circuit and a monitoring system that rolled anything older than thirty days into hourly averages. For six weeks the line lost most of its packets for about two minutes every afternoon. The warehouse noticed, and the help desk logged it as "the internet again". By the time anyone asked for the graphs, the compression had reached them. Each two-minute failure had become a small bump in a healthy-looking hour. The provider's portal showed the same thing, which was the first time the two had ever agreed. Meridian now keeps per-minute data for a year and exports a picture of anything interesting on the day it happens.


A starter plan for one circuit


All of the above, compressed into an afternoon:


  • 1. Find the demarc, photograph it, and copy the circuit ID off the label or the invoice into your documentation.
  • 2. Identify the provider gateway address from your edge router and confirm it answers a ping.
  • 3. Create the per-minute probes: gateway, plus two external anchors run by different organizations, recording latency and loss.
  • 4. Set an availability alert — a few consecutive failed probes — and route that alert around the circuit, not through it.
  • 5. Schedule a short nightly throughput sample against a target that consents, and note the ordered rate beside it.
  • 6. Create the circuit record page with the skeleton above and put a monthly rollup reminder on your calendar.
  • 7. Check your retention settings so per-minute data survives at least one full billing cycle.

That is one circuit, fully instrumented, for the cost of a few pings a minute. Every additional circuit is the same recipe with a different gateway.


Where to go next


You now have what almost none of your provider's other customers have: an independent, continuous, exportable record of what the circuit actually delivered. On a quiet month it costs you five minutes of rollup. On a bad month it is the difference between "the internet has felt off lately" and a table of timestamps. The next time the portal says green and the office says otherwise, there will be two instruments in the room, and one of them is yours. The rest of this pillar builds on this record. It covers comparing the record to what was promised, filing outages so they count, and escalating when the pattern demands it: Monitoring Your ISP & Holding Them Accountable.


Put this into practice with SysPeep Monitor

Every probe in this guide is an ordinary monitoring check. SysPeep Monitor runs them from one Windows machine: per-minute checks toward each circuit's gateway and your chosen anchors. It provides dashboards per circuit, alert rules with dependencies to keep the noise down, and reports you can put in front of a provider. The free trial installs in minutes.

Download Free TrialLearn About SysPeep