Measuring the Core Four With Free Tools: A Hands-On Lab
Four numbers describe almost everything users feel about a network. Latency measures how long a round trip takes. Packet loss measures how much traffic never arrives. Jitter measures how much the delay wobbles. And bandwidth measures how much data the path can move per second. When someone says "the network is slow," the only honest answer starts with measuring those four. The good news is that every tool you need is free. Most of them are already installed on your machine.
This is a hands-on lab, not a theory lecture. You will run real commands from your own admin workstation and read the output line by line. You will finish with something better than four numbers: a written, repeatable routine. It is one you can run in fifteen minutes flat the next time a "slow network" ticket lands. Every command comes in a Linux and a Windows flavor. Use whichever desk you are sitting at.
In this guide
- The four numbers and their instruments
- Ground rules: measuring without fooling yourself
- ping: latency, loss, and a sneaky jitter estimate
- mtr and pathping: the per-hop view
- iperf3: measuring real throughput
- The continuous option: scheduled ping logging
- The 15-minute "network is slow" runbook
- Filing results so future-you can compare
- Where to go next
The four numbers and their instruments
A quick map before we start. Each metric has one free tool that measures it well. Troubleshooting gets fast when you know which instrument answers which question.
| Metric | What it tells you | Unit | Instrument in this lab |
|---|---|---|---|
| Latency | Round-trip delay to a target | milliseconds (ms) | ping |
| Packet loss | Share of packets that never arrive | percent | ping with big samples, mtr |
| Jitter | How much the delay varies | milliseconds (ms) | ping deviation (rough), iperf3 UDP (proper) |
| Throughput | Data actually moved per second | Mbit/s | iperf3 |
One vocabulary note that will save you arguments: bandwidth is the capacity of the road — how many lanes it has. Throughput is the traffic that actually got through — trucks delivered per hour. A "gigabit link" is a statement about bandwidth. Whether you can move a gigabit through it right now is a throughput question. Tools measure throughput; brochures advertise bandwidth.
Ground rules: measuring without fooling yourself
Measurements are only as trustworthy as the setup they came from. Four habits keep yours honest:
- Test from a wired machine unless Wi-Fi itself is the patient. Wireless adds its own latency, jitter, and loss, and you cannot tell its contribution apart from the network's.
- Use the same workstation every time. Your measurements become comparable only if the instrument stays constant. Pick one machine and make it the lab bench.
- Test the same targets every time. Choose two or three anchors. Use your default gateway, one important internal server, and one stable internet address you are allowed to ping. Stick with them forever.
- Write everything down. A number without a date, a source, and a target is trivia. The last section of this lab gives you a filing system.
ping: latency, loss, and a sneaky jitter estimate
ping sends a tiny "are you there?" message (an ICMP echo request) and times how long the reply takes. It is like a tennis ball thrown against a wall, with a stopwatch running until it bounces back. That round-trip time, or RTT, is your latency. Send many balls and count the ones that never come back, and you have packet loss too.
The mistake beginners make is sample size. The default four pings on Windows can only report loss as 0, 25, 50, 75, or 100 percent. That is useless for detecting the 1–2% loss that ruins voice calls. The resolution of a loss measurement is one divided by the number of pings. So make 100 your minimum serious sample. On Linux you can also tighten the interval between pings so the test finishes quickly:
# Linux: 100 pings, 5 per second (0.2 s apart), then a summary ping -c 100 -i 0.2 192.0.2.10
(Intervals shorter than 0.2 seconds need root privileges, and flooding targets is rude anyway.) The end of the output is where the value lives:
64 bytes from 192.0.2.10: icmp_seq=98 ttl=63 time=9.02 ms 64 bytes from 192.0.2.10: icmp_seq=99 ttl=63 time=8.87 ms 64 bytes from 192.0.2.10: icmp_seq=100 ttl=63 time=9.15 ms --- 192.0.2.10 ping statistics --- 100 packets transmitted, 99 received, 1% packet loss, time 19894ms rtt min/avg/max/mdev = 8.774/9.312/24.605/1.612 ms
Read that last line like a story. min (8.77 ms) is the road with no traffic — the best this path can do. avg (9.31 ms) is the typical trip. max (24.6 ms) is the worst single trip. The gap between max and avg is your first clue about congestion. On a calm path, max and avg sit close together. A max several times the average means something occasionally made packets wait in a queue. mdev is the mean deviation — Linux's flavor of standard deviation. It is your poor-man's jitter. A small mdev means every trip took about the same time. A fat one means the delay is wobbling. That is exactly what real-time audio and video hate. And the loss line speaks for itself: 1 packet in 100 vanished. On a wired LAN, sustained loss of any amount is abnormal and worth chasing. Across the internet, an occasional fraction of a percent is life.
On Windows, the same test looks like this. There is no interval flag. The pings go about one per second, so budget two minutes:
:: Windows: 100 pings
ping -n 100 192.0.2.10
Ping statistics for 192.0.2.10:
Packets: Sent = 100, Received = 99, Lost = 1 (1% loss),
Approximate round trip times in milli-seconds:
Minimum = 8ms, Maximum = 25ms, Average = 9ms
Notice what is missing: Windows ping gives no deviation number, so no jitter estimate. PowerShell fills the gap:
Test-Connection 192.0.2.10 -Count 100 | Measure-Object Latency -Average -Minimum -Maximum -StandardDeviation
If your PowerShell objects to the property or the parameter, you are on an older build. In that case, use ResponseTime instead of Latency and drop -StandardDeviation. You still get the min/avg/max spread. And max-minus-min is a serviceable stand-in for jitter.
Tip: ping your anchors in order of distance — gateway first, internal server second, internet target third. Latency should step up at each stage. The stage where the numbers go from healthy to ugly points at the neighborhood of the problem. That is exactly the logic the runbook below turns into a routine.
mtr and pathping: the per-hop view
ping tells you how bad the trip is, but not where it goes wrong. Between you and any distant target sits a chain of routers, and each handoff is called a hop. mtr runs on Linux (install with sudo apt install mtr or sudo dnf install mtr). It combines the path-tracing of traceroute with continuous pinging of every hop at once. So you can see at which hop delay or loss begins:
# 100 rounds, report mode, wide output mtr -rwc 100 192.0.2.50 HOST: admin-ws Loss% Snt Last Avg Best Wrst StDev 1.|-- 10.0.0.1 0.0% 100 0.4 0.5 0.3 2.1 0.2 2.|-- 203.0.113.1 30.0% 100 8.2 9.1 7.9 14.3 1.0 3.|-- 198.51.100.9 0.0% 100 9.0 9.4 8.7 22.5 1.6 4.|-- 192.0.2.50 0.0% 100 9.2 9.6 8.8 19.0 1.3
Two reading rules turn this table into a diagnosis. Rule one: read the bottom line first. The final hop is the end-to-end truth — here 0% loss and a steady 9.6 ms average. So the path as a whole is healthy. Rule two: intermediate loss only matters if it continues downward. Hop 2 shows 30% loss, but hops 3 and 4 show none. That is not real loss. It is a router treating "answer pings addressed to me" as its lowest-priority chore while forwarding actual traffic perfectly. If the loss had started at hop 2 and appeared in every hop after it, the problem would genuinely begin there. The same logic applies to latency: a jump that persists through every following hop marks the slow segment. A spike at one hop only is that router being casual about its ping duties.
Also glance at the StDev column. It is the per-hop version of the jitter estimate you met in ping. It is handy for spotting which segment introduces the wobble.
Windows ships its own per-hop tool, pathping. It traces the route, quietly gathers statistics (about 25 seconds per hop — a genuine coffee moment), then prints per-hop loss:
pathping 192.0.2.50
Computing statistics for 75 seconds...
Source to Here This Node/Link
Hop RTT Lost/Sent = Pct Lost/Sent = Pct Address
0 admin-ws [10.0.0.20]
0/ 100 = 0% |
1 1ms 0/ 100 = 0% 0/ 100 = 0% 10.0.0.1
0/ 100 = 0% |
2 9ms 30/ 100 = 30% 30/ 100 = 30% 203.0.113.1
0/ 100 = 0% |
3 9ms 0/ 100 = 0% 0/ 100 = 0% 192.0.2.50
Read it with the same two rules; the layout differs, the logic does not. (If you prefer mtr's live view on a Windows desk, it runs happily under WSL, the Windows Subsystem for Linux.)
iperf3: measuring real throughput
Ping is a stopwatch; it times one tiny packet and tells you nothing about capacity. To measure throughput you need to actually haul freight: fill the path with data on purpose and count what arrives. That is iperf3, and it needs two machines you control — one at each end of the path you care about. Install it with sudo apt install iperf3 or sudo dnf install iperf3. On Windows, download the prebuilt zip, unpack it, and run it from that folder in PowerShell. The commands are identical on both.
Start the listener on the far machine. That could be a server in the closet, a VM at the branch office, whatever sits at the other end of the path under test. And allow TCP and UDP port 5201 through that machine's firewall:
# on the far machine ("server" just means "listener")
iperf3 -s
-----------------------------------------------------------
Server listening on 5201
-----------------------------------------------------------
Then from your workstation, run a ten-second TCP test toward it:
iperf3 -c 192.0.2.40 [ ID] Interval Transfer Bitrate Retr Cwnd [ 5] 0.00-1.00 sec 112 MBytes 941 Mbits/sec 0 408 KBytes [ 5] 1.00-2.00 sec 112 MBytes 941 Mbits/sec 0 408 KBytes [ 5] 2.00-3.00 sec 112 MBytes 940 Mbits/sec 0 408 KBytes ... - - - - - - - - - - - - - - - - - - - - - - - - - [ ID] Interval Transfer Bitrate Retr [ 5] 0.00-10.00 sec 1.10 GBytes 941 Mbits/sec 0 sender [ 5] 0.00-10.00 sec 1.09 GBytes 938 Mbits/sec receiver
Three things to read. The Bitrate on the receiver line is the headline: what actually got through. On a healthy gigabit LAN expect roughly 940 Mbit/s. Protocol overhead eats the rest, so do not chase the missing 60. The Retr column counts TCP retransmissions: packets lost under load that had to be sent again. Zero is lovely. A steadily climbing Retr means the path drops packets when stressed. That is loss that an idle-time ping test will never show you. And if sender and receiver totals differ wildly, packets are dying in between.
Two flags earn their keep immediately. -R reverses the direction, so the server transmits and you receive. Test both ways, because paths are often asymmetric and users upload as well as download. -P 4 runs four parallel streams. On long-latency paths (a WAN link to another city) a single TCP connection often cannot fill the pipe by itself. On such paths, four streams summed on the [SUM] line give a fairer picture of what the link offers a crowd of users.
Finally, UDP mode is where jitter gets measured properly instead of estimated. Send a fixed, modest rate — the kind of stream a phone call or video actually is. The receiver reports how the arrival timing wobbled and what went missing:
iperf3 -c 192.0.2.40 -u -b 100M [ ID] Interval Transfer Bitrate Jitter Lost/Total Datagrams [ 5] 0.00-10.00 sec 119 MBytes 100 Mbits/sec 0.113 ms 12/86241 (0.014%)
That jitter figure (0.113 ms) and loss ratio are precisely the two numbers real-time traffic lives and dies by, measured on your actual path instead of guessed.
Warning: iperf3 saturates the path on purpose — that is its job. A long test across a busy WAN link at 10 AM is a small outage. Keep tests to ten seconds during business hours. Schedule the big ones after hours. Warn colleagues before testing shared links. And never aim it at machines or networks you do not own.
The continuous option: scheduled ping logging
Everything so far is on-demand. And intermittent problems are cowards — they never perform while you are watching. The cheap fix is a scheduled job that logs a small ping summary every five minutes, forever, from an always-on machine. When "it was slow yesterday around three" arrives, you will have data from yesterday around three.
On Linux, save this as a script, make it executable with chmod +x, and add the cron line with crontab -e:
#!/bin/sh # pinglog.sh - append one summary line per run TARGET=192.0.2.10 mkdir -p "$HOME/pinglogs" STAMP=$(date -u +%Y-%m-%dT%H:%M:%SZ) LINE=$(ping -q -c 20 -i 0.2 "$TARGET" | tail -n 2 | tr '\n' ' ') echo "$STAMP $LINE" >> "$HOME/pinglogs/$TARGET.log" # crontab entry: every 5 minutes */5 * * * * $HOME/bin/pinglog.sh
Each line of the log ends up looking like this (timestamp, then ping's own summary):
YYYY-MM-DDTHH:MM:SSZ 20 packets transmitted, 19 received, 5% packet loss, time 3861ms rtt min/avg/max/mdev = 9.1/9.8/41.2/3.9 ms
On Windows, the same idea runs from Task Scheduler. Save this as pinglog.ps1 and create a task that runs it every five minutes with powershell.exe -NoProfile -File C:\Scripts\pinglog.ps1:
# pinglog.ps1 - append one summary line per run
$target = "192.0.2.10"
$stamp = (Get-Date).ToUniversalTime().ToString("yyyy-MM-ddTHH:mm:ssZ")
$pings = Test-Connection $target -Count 20 -ErrorAction SilentlyContinue
$got = @($pings).Count
$avg = [math]::Round(($pings | Measure-Object Latency -Average).Average, 1)
"$stamp sent=20 received=$got avg=${avg}ms" | Add-Content C:\PingLogs\gateway.log
A five-minute grid of loss and latency, kept for months, answers questions no single test can. Does the wobble follow business hours? Did it start the day of the firmware update? This is, honestly, a bicycle-parts version of what a monitoring system does. Once you also want bandwidth history, alerting, and graphs, the grown-up route is polling your devices' counters over SNMP. The SNMP Monitoring guides cover that from zero.
The 15-minute "network is slow" runbook
Now assemble the instruments into a routine. The power of a runbook is sameness: same commands, same targets, same order, every time. That makes results comparable and keeps anything from getting skipped in the adrenaline of an outage. Here is the sequence, with a time budget:
- Minutes 0–2 — Pin down the complaint. Who is affected, which application, from which machine, wired or Wi-Fi, since when, constant or in bursts? "Slow" spelled out precisely is already half a diagnosis — and it decides which far target you test toward.
- Minutes 2–4 — Ping the default gateway. 100 pings from your wired lab workstation. Ugly numbers here mean the problem is inside the building — local segment, switch, or cabling. In that case, there is no point testing further out yet.
- Minutes 4–6 — Ping the far anchor. The server or service from the complaint, or your standard internet anchor. Clean gateway plus ugly far numbers moves the suspect beyond your LAN.
- Minutes 6–9 — Run mtr or pathping toward the far target. Apply the two reading rules and note the hop where trouble genuinely starts.
- Minutes 9–12 — If the complaint smells like throughput (transfers crawl, backups overrun) and you have an iperf3 listener in the right place: ten seconds TCP each direction. Note Bitrate and Retr both ways.
- Minutes 12–15 — Compare against baseline and write the verdict. One of: local network, our uplink, beyond our edge, far end, or — perfectly respectable — numbers healthy, look above the network (DNS, the server itself, the application). File the outputs before touching anything else.
One note of respect for that last verdict: proving the network innocent in fifteen minutes, with numbers, is just as valuable as finding it guilty.
Filing results so future-you can compare
A measurement you cannot find or compare later is a measurement wasted. Keep one folder with two subfolders — baselines and incidents — and one boring, sortable naming convention:
netlab/
baseline/
YYYYMMDD-gateway-ping.txt
YYYYMMDD-fileserver-iperf3.txt
incidents/
YYYYMMDD-HHMM-slow-crm-mtr.txt
Start every file with the same five header lines, then paste the raw output unedited:
when: date and time, and your timezone from: admin-ws, wired, 1 Gbit/s port target: 192.0.2.50 (crm server) command: mtr -rwc 100 192.0.2.50 why: ticket 4181, "CRM freezes since this morning"
Two habits complete the system. First, record the exact command with every result — a number is only comparable to another number produced the same way. Second, refresh the baseline folder on a schedule. Run the full battery (100-count pings to each anchor, one mtr per anchor, iperf3 both directions to your listener). Do this once a quarter and after any network change, during a known-quiet, known-good hour. Baselines are what turn "is 9 ms bad?" from a philosophy question into a ten-second lookup. Last quarter it was 9 ms too — the network is fine. Or it was 2 ms — something changed. You even know roughly when.
Where to go next
You can now measure all four core metrics with free tools and read the outputs like a native. And — more valuable than either — you have a repeatable routine and a filing habit that make every future measurement comparable to the last one. One natural next question is what counts as a good number for each metric on each kind of path. Another is how the four interact when things go wrong. The other guides in The Core Network Metrics take those up. The wider topics library goes deeper on the tools themselves.
Put this into practice with SysPeep Monitor
This lab is the manual version of what monitoring software does all day, every day. SysPeep Monitor keeps the measuring running around the clock. It collects response times, packet loss, and per-interface throughput over SNMP, WMI, and friends. It graphs the history and alerts you when a number leaves its normal range. Your runbook gets a head start, because the "since when?" question is already answered. The free trial installs on any Windows machine in minutes.
Download Free TrialLearn About SysPeep