Endpoint-Side Metrics: What the Laptop Knows That the Switch Doesn't
Dana says her laptop is slow. I have taken that ticket, and so will you. You check the switch port her desk is patched into: link up, gigabit, zero errors, barely any traffic. You check the server she uses: idle. You check the internet link: half empty. Everything you can see is fine. Dana is still slow. Here is why: Dana's laptop is on Wi-Fi. Its disk has been pegged at 100% by a background scan since nine. And its DNS lookups are taking a full second each. None of that exists on any switch, anywhere.
This guide is about the other half of the picture: the numbers only the endpoint can report. The laptop knows how its own CPU, memory, and disk feel. It knows how strong the Wi-Fi signal is where it is sitting. It knows how long its last address lease took and how far away the gateway is. It knows whether the VPN is connected, and how long a real request to a real application took from its own seat. The switch cannot know any of this. Polling it harder will not change that. It will only give you a more frequent record of a port that is fine.
By the end you will know which endpoint-side metrics matter and what each one implicates. You will know how to collect them lightly and without becoming a surveillance department. You will also know how much data you are really signing up for.
In this guide
- Why the switch cannot see any of this
- Device health: the slowness that is not network at all
- The local network from the client's side
- The path and the application, as the client sees them
- The metrics table: what each one implicates
- Collecting lightly and safely
- Sampling frequency and data volume, honestly
Why the switch cannot see any of this
A switch sees frames arriving on a port and leaving on another. It can count them, count the broken ones, and tell you whether the link is up. That is the entire extent of its knowledge. It has no idea whether a frame was delayed for two seconds inside the laptop before it was sent. It does not know whether the wireless radio retransmitted it five times. It does not know which DNS server the laptop decided to ask. It does not know whether the VPN client silently dropped and reconnected. Nor does it know whether the laptop is at a desk or at a kitchen table forty kilometres away.
The access point knows a little more. It sees signal from its side and can report client counts and retries. But its view is still the view from the ceiling, not from the seat. The server, at the far end, knows only how long it took to build its answer, not how long the answer took to arrive. Everything that happens in the first few metres of the journey is invisible from the middle and the far end. And that is where a surprising amount of "slow" lives. So some of the measuring has to happen on the user's machine: not all of it, and not on every machine at first, but some.
Device health: the slowness that is not network at all
A struggling device produces symptoms that are indistinguishable, from the user's chair, from a struggling network. Pages load slowly, video calls stutter, the file share "hangs." Think of a car with the handbrake half on: every road feels slow, and the driver blames the roads. Before you look at a single network number, look at these.
CPU
Sustained processor saturation is the obvious one, but the subtle version matters more: one core pinned by a single process. Modern machines have many cores. The total may read as a comfortable 30% while the one core the user's application is waiting on is at 100%. Record the total and the busiest process name. That is because "CPU high" is a symptom and "the security scanner is eating a core" is a diagnosis.
Memory
When a machine runs low on memory, the operating system starts moving data to disk and back, a process called paging or swapping. Everything slows, in a way that feels like the network because the pauses happen while the user waits. Available memory is the number to watch, along with the paging rate if your counters expose it. A browser with sixty tabs is the classic culprit; a leaking line-of-business application is the sneaky one.
Disk
The disk is the layer most often mistaken for the network. That is because a busy disk delays exactly the things people associate with the network: opening files, saving documents, loading applications. Watch disk active time (how much of the time the disk is busy) and the queue length (how many requests are waiting). A nearly full disk also gets slower, particularly a solid-state drive with no room left to shuffle blocks, so record free space too.
Battery and power mode
A laptop on battery in a power-saving mode deliberately throttles its processor and often its wireless radio too. Recording whether the machine is on mains power and which power plan is active explains a whole category of "it's slow in the meeting room" complaints. Those would otherwise get blamed on the meeting room's access point.
Background work
Operating system updates, security scans, search indexing, cloud file synchronization catching up after a weekend, and backup agents all run in the background. All are heaviest exactly when people arrive in the morning and turn their machines on. A field that records "updates pending or installing" and "last reboot time" turns a mysterious slow Monday into an obvious one. Every background job in the building has independently decided that nine o'clock is the quiet time.
The local network from the client's side
Now the first few metres. The point of measuring here is that these numbers describe the connection as this device experiences it. That is different from how the access point or switch experiences it.
Wi-Fi signal, band, rate, and retries
The wireless adapter knows its received signal strength, and which band and channel it is on. It knows the data rate it has negotiated, and (on many adapters) how often it had to retransmit. A weak signal, a device stubbornly clinging to a distant access point, or a laptop that dropped to the crowded lower band all show up here and nowhere else. Windows reports signal as a percentage rather than the decibel figure engineers use. The trend for one machine in one place matters more than the unit. The Wi-Fi experience metrics guide goes deep on what each radio number means.
Wired link speed and DHCP timing
For desk-bound machines, record the negotiated link speed. A port that should be gigabit and has settled at 100 megabits is almost always a damaged cable. The user experiences it as "the file server is slow" while every switch graph looks perfect. I once spent two days tuning a file server for a complaint that turned out to be a crushed patch lead under a desk leg. Record, too, how long the machine's last DHCP request took and whether renewals are succeeding. That describes the DHCP server, the relay on the local router, and scope exhaustion. It does so from the one vantage point that actually has to wait for the answer.
Gateway round-trip time
If you collect only one local-network number, collect this one. The gateway is the local router that everything leaves through. And the round-trip time (RTT) is how long a tiny message takes to reach it and return. On a wired desk it should be well under a millisecond; on healthy Wi-Fi, a few milliseconds. When it climbs into tens or hundreds of milliseconds, or messages are lost entirely, the device's local connection is unhealthy. In that case, every application on it will feel slow. This measurement never leaves your building. So a bad number here cleanly rules out the internet, the VPN, and the application. It points straight at the device, the air, or the local switch.
The path and the application, as the client sees them
DNS lookup time
The laptop resolves names before nearly every action, and it may not be asking the resolver you think. A VPN client can swap the DNS servers without mentioning it (VPN clients are fond of DNS games). A home router may intercept lookups. And a misconfigured adapter may try a dead server first and time out before falling back. Timing a real lookup from the client, and recording which server answered, exposes all of that.
VPN state and public IP
For remote and travelling users, record whether the VPN is connected, and which gateway it connected to. Also record the round-trip time through the tunnel to something inside the office. A tunnel that detours through a distant concentrator, or a client that reconnects every few minutes, explains a lot of remote-worker misery. The machine's public IP address and internet provider tell you which network the user is really on. A "the office is slow" ticket from someone who turns out to be at a coffee shop is a different ticket. Because public addresses can identify a person's home, treat this field with care (more below).
Application response, measured from the seat
Finally, the number closest to what the user feels: how long a real request to a real service took, from this machine. Timing a single web request and splitting it into phases is the most informative thing an endpoint probe can do. The phases start with name lookup and TCP connection (the basic handshake that opens a connection before any data moves). Next comes TLS handshake (the encryption setup), followed by time to first byte (the wait for the server to begin answering: mostly server think time). Then comes total time (which adds the transfer of the whole response). Modern Windows ships a command-line tool that reports all of them:
curl.exe -o NUL -s -w "dns=%{time_namelookup} connect=%{time_connect} tls=%{time_appconnect} firstbyte=%{time_starttransfer} total=%{time_total}" https://crm.example.com/login
Each value is a running clock in seconds, so subtract each phase from the previous one to get its own duration. A jump between connect and TLS points at the path or a struggling front door. A jump between TLS and first byte is the application thinking. A gap between first byte and total is a big response crossing a slow link. In Windows PowerShell use curl.exe, because the short name is an alias for something else. For a file server, the equivalent is timing the open of a small known file on the share.
Most of the other numbers take one line each in PowerShell, which is why a scheduled script is such a reasonable place to start:
# Default gateway, then four timed pings to it
$gw = (Get-NetRoute -DestinationPrefix "0.0.0.0/0" | Sort-Object RouteMetric | Select-Object -First 1).NextHop
Test-Connection -ComputerName $gw -Count 4
# Wi-Fi signal, radio type, channel, and rates as this laptop sees them
netsh wlan show interfaces | Select-String "Signal|Radio type|Channel|Receive rate|Transmit rate"
# Milliseconds to resolve a real name from here
(Measure-Command { Resolve-DnsName www.example.com -DnsOnly }).TotalMilliseconds
# Device pressure: CPU, available memory, disk busy time
Get-Counter '\Processor(_Total)\% Processor Time','\Memory\Available MBytes','\PhysicalDisk(_Total)\% Disk Time'
Wrapping those lines in a loop that writes one summary row every few minutes is a short afternoon's work. And the PowerShell monitoring probe guide is a ready-made skeleton for the script.
The metrics table: what each one implicates
The value of endpoint metrics is not the numbers themselves but what a bad number implicates: which layer to suspect and which to clear. This table is the cheat sheet. Two terms in it need a word. An anchor is a fixed target you time against every interval. The SaaS front door is the login page of an application somebody else hosts.
| Metric | Comes from | When it is bad, it implicates |
|---|---|---|
| CPU total and busiest process | OS performance counters | Device: a runaway process, scan, or update |
| Available memory, paging rate | OS counters | Device: too many tabs or a leaking app; slow page loads |
| Disk active time, queue, free space | OS counters | Device: scans, indexing, sync, a nearly full or failing disk |
| On battery, power plan | OS power status | Device: throttled CPU and radio; "slow in the meeting room" |
| Updates pending or installing | OS update status | Device: background download and install; slow Mondays |
| Wi-Fi signal, band, channel | Wireless adapter | Local: distance, walls, wrong band, sticky roaming to a far AP |
| Wi-Fi negotiated rate, retries | Wireless adapter | Local: interference or congestion on the air |
| Wired link speed and duplex | Network adapter | Local: bad cable or patch when it is 100 Mb instead of 1 Gb |
| DHCP time to lease, renewal failures | Lease timing, OS logs | Local: slow or exhausted DHCP, relay trouble |
| Gateway round-trip and loss | Ping to default gateway | Local: the air or the first switch; clears everything beyond the building |
| DNS lookup time, which resolver | Timed query | Path (or local): a slow or wrong resolver, or a VPN that swapped the resolver |
| VPN connected, gateway, tunnel RTT | VPN client, ping through tunnel | Path: tunnel overhead, concentrator load, a long detour |
| Public IP and provider | External lookup | Path: which ISP the user is really on; home versus office |
| Round-trip to a few anchors | Ping or HTTP to the office edge, a public resolver, the SaaS front door | Path: provider or transit trouble, localized by which anchor got worse |
| App time to first byte | Timed request | Application: server think time, once lookup and connect are subtracted |
| App total time | Timed request | Application and path together: response size over available throughput |
Notice the shape of the table: the first rows clear or convict the device without a packet leaving it. The next few do the same for the first few metres. Only then do you spend attention on the internet and the application. Read it in that order. Yes, every time. Yes, even when the ticket already says "internet".
Collecting lightly and safely
There are two reasonable ways to get these numbers off a machine, and the right one depends mostly on how many machines you have.
Scheduled script or lightweight agent?
A scheduled script is a task the operating system runs every few minutes. It gathers the numbers, writes one line to a file or posts it to a collector, and exits. It is transparent (anyone can read it), free, easy to change, and ideal for a handful of reference machines. Its weaknesses are that it only samples the moment it runs, and that deploying it across hundreds of machines becomes a project in itself. A lightweight agent is a small always-running program that samples continuously, keeps a short history, and reports summaries. It catches short spikes a script would miss, at the cost of another piece of software to maintain and trust on every machine. Start with a script on a few machines; graduate to an agent when the machine count makes the script painful.
Report summaries, not raw samples
Whatever collects the data, have it send summaries. For each interval, send the average and the worst value of each metric, plus a few facts about the machine's state. Do not stream every ping or ship raw counters. The goal is a timeline you can lay next to a complaint, not a data lake.
Do not let the probe become the problem
The probe runs on the user's machine, so it must be nearly invisible. Ping a handful of targets a handful of times, not continuously. Time one small request, not a full page with images. A traceroute is a test that lists every router between the machine and a target, one hop at a time. Run it rarely, or only when round-trip numbers cross a threshold. That is because a traceroute is dozens of packets. Run the script at low priority. If the probe ever shows up as the busiest process in its own CPU column, it has failed at its one job.
Privacy and consent
This is where endpoint monitoring earns or loses the trust that makes it possible. The rule is collect health, not content. Health is CPU, memory, signal strength, round-trip time, and how long the CRM's login page took to answer. Content is which websites someone visited, what they typed, what documents they opened, screenshots, or a full list of running programs. The first helps you fix things; the second helps nobody and will, correctly, be seen as surveillance. Watch the borderline fields: the busiest process name is diagnostic health, but a full process list is an activity log. A public IP address can identify a remote worker's home, so consider storing only the provider name.
Then be transparent. Write one plain-language page that says what is collected, why, how often, how long it is kept, and who can see it. Get management and, where they exist, employee representatives to sign off before the first script runs on anyone's machine but your own. Start with volunteers. A monitoring program people understand is one they will help you with. The same program discovered by accident is one they will fight, and they will be right to.
Tip: the simplest privacy test is to imagine the collected row being read aloud in a team meeting. "Dana's laptop had 40% disk free and 9 ms to the gateway" embarrasses nobody. If a field would make the room go quiet, you do not need it.
Sampling frequency and data volume, honestly
New endpoint-monitoring projects fail in one of two directions. One is sampling so rarely that the data never lines up with a complaint. The other is sampling so eagerly that the data becomes a storage problem nobody looks at. Some arithmetic keeps you honest.
At Harbourview Clinic the first endpoint probe sampled every workstation every ten seconds and shipped every raw ping to a collector in the server room. That was because the project lead wanted "the full picture". Within a fortnight the collector's disk was full. The oldest rows had been purged to make room. And the one week anyone needed to look at was the week that had gone. On the workstations the probe appeared in its own CPU column as the busiest process on about half the fleet. So a good part of the slowness it was reporting was itself. The minutes of the next meeting recorded the project as "paused". It restarted a month later at one summary row every five minutes and has been quietly useful ever since.
Suppose each machine reports one summary row every five minutes during a working day of about ten hours. Suppose each row is twenty fields or roughly 200 bytes. That is 120 rows and about 24 KB per machine per day. Two hundred machines produce 24,000 rows and around 5 MB a day. Over a year that is under 2 GB. That is comfortably a job for a small database or even a well-organized folder of daily files. Move to one-minute sampling and everything is five times larger. That is still manageable, but now the collector handles a spike every morning as every machine wakes at once.
Five minutes is a good default for reference machines. It lines up naturally with how most infrastructure pollers work, which makes correlation easy. One minute is worth it for the few machines you are actively investigating. Slower than fifteen minutes and the complaint will routinely fall between two samples. Whatever you choose, keep the raw rows for a couple of weeks and roll them up to hourly averages and maxima after that. Questions about last quarter are trend questions.
- Reference machines, normal operation: every five minutes, summaries only.
- A machine under active investigation: every minute, for the duration, then back down.
- Application timings: one small request per application per interval, staggered so a hundred machines do not hit the login page in the same second.
- Retention: raw for two weeks, hourly rollups for a year, stated on the transparency page.
Where to go next
The endpoint sees the two layers the switch cannot: the device itself and the first few metres of its connection. A short script, a five-minute schedule, a summary row, and a clear privacy page are enough to start seeing them. None of it asks the switch to learn anything new. The next time Dana says her laptop is slow, you will be able to ask the one machine in the building that knows. Once the numbers are flowing, Experience Scores shows how to fold them into one honest number. The guide Closing the “It Feels Slow” Gap shows how to match them to complaints. And Digital Experience Monitoring: From Device Health to User Happiness holds the rest of the series.
Put this into practice with SysPeep Monitor
Endpoint numbers are only half a diagnosis. The other half is knowing what the access point, the switch, the DHCP server, and the VPN gateway were doing at the same minute. SysPeep Monitor covers that half. It discovers your network devices and servers and collects their health over SNMP and WMI. It keeps the graphs and alerts in one web console. It has remote probes for the sites where your users actually sit. The free trial runs on any Windows machine.
Download Free TrialLearn About SysPeep