Home › Topics › Jitter & Real-Time Traffic › Diagnosing Jitter

Diagnosing Jitter Sources


The ticket never uses the word jitter. It says the calls "sound robotic," or "like he was underwater," or "kept cutting out, but only sometimes." You run a speed test: plenty of bandwidth. You ping the phone system: perfectly normal. And yet somewhere in the building, a sales call has just turned into a bad science-fiction impression. That mismatch — every quick check looks fine while calls sound terrible — is the signature of jitter. Jitter is the variation in how long each packet takes to arrive.


Naming the problem is the easy half. This guide is about the hard half: finding the source. The good news is that jitter keeps a short list of suspects. On a small or mid-size network, nearly every case traces back to one of six causes, and each leaves distinctive fingerprints in graphs and counters. You will meet the suspects in order of likelihood and learn the evidence that convicts each. Then you will walk a four-step isolation sequence that works on all of them. There is a worked example and a cheat-sheet table at the end.


One assumption before we start: you know roughly what jitter is and you have some way to measure it. If either half feels shaky, the companion guides on what jitter actually is and how to measure it credibly fill those gaps. This article is purely the hunt.


In this guide

  • Jitter is waiting: the one idea behind every cause
  • The six suspects, in order of likelihood
  • The isolation workflow: catch, bisect, correlate, confirm
  • A worked mini-case: the 9:40 robot voice
  • The suspect cheat sheet
  • Where to go next

Jitter is waiting: the one idea behind every cause


A voice call is a metronome. The sending phone emits one small packet every 20 milliseconds — fifty per second, tick, tick, tick. The listening end wants to play them back at exactly that rhythm. The network, though, delays each packet by a slightly different amount, so the metronome arrives smeared. A small holding area at the receiving end, the jitter buffer, re-spaces the ticks. That works until the variation exceeds what it can absorb. Then the robot voice appears. The jitter buffer guide covers that machinery in detail. What matters here is where the variation comes from in the first place.


Here is the idea that organizes the whole hunt: steady delay does not cause jitter. A call that always takes 80 ms to cross the network sounds fine; the buffer settles in and nobody notices. Jitter is caused by variable delay, and variable delay has essentially one source: waiting. A packet waits in a queue behind other traffic. It waits for a busy CPU to forward it. It waits for a crowded Wi-Fi channel to go quiet, or for a damaged frame to be transmitted a second time. Every suspect on the list below is simply a place in the path where packets wait by different amounts from one moment to the next. Find the waiting room, and you have found your jitter.


The six suspects, in order of likelihood


The order matters: it reflects how often each suspect turns out to be guilty on small networks. Work the list top to bottom and you will usually stop early.


Suspect 1: Congestion bursts on a shared link

Voice packets are small and polite — a couple of hundred bytes, fifty times a second, roughly 100 kbps per call. Bulk traffic is their opposite. Think of backups, cloud sync clients, OS update downloads, or somebody dragging a video file onto a shared drive. These are streams of full-size packets sent as fast as the link will carry them. When both share a link that is momentarily full, each voice packet queues behind a constantly changing number of big packets. The arithmetic is unkind: on a 20 Mbps uplink, one 1,500-byte packet takes about 0.6 ms to transmit. So a queue fifty packets deep adds 30 ms of delay. And a queue that is fifty deep one moment and five deep the next is a jitter machine. This is the most common jitter source in ordinary offices, by a wide margin.


The fingerprint: jitter that correlates with activity, not location. It is worst during the morning backup window or the 9 AM sync rush. It hits wired and wireless users alike. On asymmetric internet connections it often favors one direction, because the thin upload side chokes first.


The first check: utilization on the suspect link at the complaint times, plus that interface's out-discards counter. That counter is the count of packets the device threw away because its outbound queue was full. Discards prove queuing happened even when a five-minute utilization average looks innocent. Averages hide exactly the bursts that cause jitter, a deception unpacked in how full is too full. And when the queue is oversized, congestion graduates from a 30 ms nuisance to whole seconds of delay. That failure mode is bufferbloat, jitter's dramatic older sibling.


Suspect 2: Wi-Fi contention

Wireless is a shared room in which only one device may talk at a time. Every client and the access point itself compete for airtime. They wait randomly when someone else is transmitting and retransmit frames that arrive damaged by interference or distance. Each of those mechanisms adds a different small delay to each packet — which is the definition of jitter. The radio layer retries damaged frames so quickly that timing trouble usually shows up before packet loss does. On Wi-Fi, jitter is the early warning and loss is the late stage.


The fingerprint: only wireless users suffer. Wired desks are clean. The complaints cluster by geography (the far corner, the conference room, suspiciously near the kitchen and its microwave) and by occupancy. A room that is fine at 8 AM struggles when thirty laptops arrive. The same laptop often behaves perfectly at a different desk.


The first check: put a wired machine next to the suffering wireless one and measure both at the same time. The difference between the two results is the radio's contribution, isolated in one move. Then look at the access point's retry rates and client counts. Wireless trouble is its own discipline — the Wi-Fi loss guide covers the radio side in depth.


Suspect 3: An edge device under load

The small firewall at your internet edge is routing, translating addresses, and running the VPN. If the security features are switched on, it is also opening and inspecting packets as they pass. Each of those jobs costs CPU time per packet. While the processor has headroom, per-packet handling time is consistent. When it runs hot, packets queue up waiting for processor attention, and per-packet delay starts to swing. That is jitter for everyone whose traffic crosses the box, in both directions, even when the links themselves are half idle.


The fingerprint: everybody behind the device is affected, wired and wireless, and yet link utilization looks unremarkable. The tell is a device CPU graph that climbs at exactly the minutes calls degrade. This suspect often appears shortly after someone enables a new inspection feature, or after the office quietly grows past what the little box was sized for.


The first check: the device's CPU history next to the complaint timestamps. If they move together, confirm during a maintenance window by briefly disabling the heaviest inspection feature and measuring again.


Suspect 4: Duplex and physical problems

Modern Ethernet runs full duplex: both ends transmit and receive simultaneously. Its ancestor, half duplex, takes turns. A duplex mismatch happens when one end of a cable believes the link is full duplex and the other believes it is half. Classically, this happens because one port was hard-coded while the other was left to autonegotiate. An autonegotiating port that hears no negotiation falls back to half duplex. The link comes up and works when quiet. But under load the half-duplex side keeps detecting phantom collisions. Frames arrive damaged, and retransmissions add loss and wildly variable delay on that one segment. Damaged cables, failing transceivers, and abused patch cords produce the same signature by corrupting frames outright.


The fingerprint: the problem is path-specific rather than time-specific — one desk, one phone, one uplink, at any hour, getting worse as traffic rises. And there is almost always a second witness: an error counter quietly incrementing on a port somewhere in the path.


The first check: walk the victim's path port by port and read the error counters. A healthy port shows essentially zero new errors per day. Anything steadily climbing deserves a look at both ends of that cable. Do the two ports agree on speed and duplex, and does the count freeze when you swap the cable?


Suspect 5: The path changed mid-call

Rare, but real, and baffling when nobody thinks of it. Routing is allowed to change its mind. For example, a WAN link fails over to backup and later returns. An ISP shifts traffic to a different path. A dual-link setup moves your flow between circuits. If that happens mid-call, every subsequent packet travels a different distance. Latency takes a sudden step up or down. A brief burst of packets arrives late or out of order, and the jitter buffer audibly struggles for a second or two while it adapts. If the path flaps repeatedly, so does the call.


The fingerprint: a step, not noise. Latency history sits flat at one level, then flat at a different level, with the trouble concentrated at the transitions. The trouble hits many users at the same instant, often matching a failover event in a log somewhere.


The first check: a traceroute during a bad spell compared with one from a good spell. A different list of hops confirms the path moved; latency graphs that show plateaus rather than spikes say the same thing in a single picture.


Suspect 6: The endpoint itself — the suspects everyone forgets

Not every robot voice is the network's fault. A laptop determined to save battery will put its Wi-Fi radio to sleep between packets and accept delivery in clumps. That is jitter manufactured in the last meter, invisible to every network graph you own. USB headsets carry their own tiny buffers and their own occasional firmware moods. A PC running at 100% CPU starves its softphone of processor time, producing audio glitches that the human ear cannot distinguish from network jitter. A VPN client encrypting every packet adds its own variable delay. These causes thrive because nobody suspects them: the network gets blamed, measured, and acquitted.


The fingerprint: one user, wherever they go. The problem follows the laptop, not the desk and not the time of day. Your measurements to their location come back clean while the user insists, truthfully, that the call was terrible. When the dashboard and the human disagree, look at the human's equipment.


The first check: swap things. A different headset, a different machine, the power plan set to high performance, Wi-Fi power saving disabled, a wired connection for a day. Each is a two-minute experiment that convicts or acquits the endpoint faster than any packet capture could.


The isolation workflow: catch, bisect, correlate, confirm


Knowing the suspects is half the job; the other half is a repeatable sequence that turns "calls sound weird sometimes" into a named culprit. It has four steps, always the same four.


Step 1: Reproduce it — or catch it live

Jitter is a rush-hour phenomenon, and a measurement taken at a quiet moment proves nothing except that quiet moments are fine. You have two options. The first is to reproduce it on demand. Make a test call while starting the load you suspect — kick off a large upload and listen. The second, for intermittent cases, is to instrument and wait. Run a continuous jitter measurement every minute and ask users to note the clock time of bad calls. Train them gently on this; "it was doing it again" is useless, while "about 9:40, Tuesday" is gold.


Step 2: Measure at two points to bisect

This is the core trick of the entire hunt. Run two measurements at the same time that differ by exactly one segment of the path, and compare. A wired desktop next to the wireless victim isolates the radio. A measurement from a LAN desktop to your edge router, alongside one from the edge onward to a steady internet target, splits inside from outside. Each well-chosen pair cuts the search space in half, and two or three pairs corner most culprits.


You do not need special tooling for a first rough split — even a plain ping makes jitter visible as scatter in the response times:


Reply from 203.0.113.10: time=12ms
Reply from 203.0.113.10: time=13ms
Reply from 203.0.113.10: time=49ms
Reply from 203.0.113.10: time=12ms
Reply from 203.0.113.10: time=74ms
Reply from 203.0.113.10: time=14ms

A steady 12 with lurches to 49 and 74 is textbook variable queuing somewhere along that path. For real jitter numbers — and the reasons averages will lie to you — use the methods in measuring jitter properly. To judge whether the numbers you get are actually bad, hold them against the per-workload targets.


Step 3: Correlate timestamps with counters

Now line the complaint minutes up against the boring numbers you already collect: interface utilization, out-discards, error counters, device CPU. The guilty resource is the one whose graph moves at the same minutes the calls fall apart. Congestion shows a utilization plateau with discards climbing. An overloaded edge shows CPU spikes with modest link usage. A physical fault shows error counters marching upward at every hour, indifferent to the business day. This is also where a monitoring history quietly pays for itself: you cannot retroactively measure last Tuesday.


Step 4: Confirm by removing the suspect

A correlation is a strong accusation, not a conviction — graphs can move together by coincidence. The confession comes from making one change and watching jitter respond. Move the backup window two hours: the spikes should move with it. Give voice its own protected queue at the congested link (its own guide in this topic): jitter should fall while the load continues. Fix the duplex setting or swap the cable: the error counter freezes and the jitter goes with it. Hand the user a different headset: one person's world improves overnight. If jitter survives the removal of a suspect, the suspect was innocent — go back to the list. And be ready for the occasional conspiracy. A congested uplink and an aggressive laptop power plan can work together, so fixing one improves matters without curing them.


Tip: measure while it hurts. The single most common diagnostic mistake with jitter is testing at 2 PM when the calls break at 9:40 AM. Then comes the conclusion that "the network is fine," and the ticket is closed. Numbers collected while everything is healthy acquit everyone. Schedule your tests — or your monitoring — to be watching when the crime is committed.


A worked mini-case: the 9:40 robot voice


A 40-person office on a cloud phone system starts logging complaints: calls "sound like robots," always in the morning, roughly 9:30 to 10:30. Both wired and wireless users are affected, which immediately demotes Wi-Fi contention (suspect 2). Everyone affected plus a strong time correlation points at congestion (suspect 1) or an overloaded edge (suspect 3).


Catch: a continuous jitter measurement to a steady external target, once a minute, runs for two days. Baseline sits at 3–5 ms; between about 9:38 and 10:22 it spikes to 35–70 ms, both mornings. The complaints now have coordinates.


Bisect: a second measurement from a desktop to the edge router's inside address stays flat at 1–2 ms all morning. The LAN is acquitted; the trouble lives at or beyond the edge.


Correlate: the WAN interface graphs tell the story. The 20 Mbps upload direction is flat-topped — pinned at its ceiling — from 9:35 to 10:20. The interface's out-discards counter gains a few thousand per hour in exactly that window. The firewall's CPU idles at 30%, which acquits suspect 3. A per-device traffic view names names: three design-team PCs are saturating the upload. A question in the hallway completes the picture. The team drops the previous day's photo shoots into a synced folder each morning, and the sync client dutifully uploads gigabytes at full throttle.


Confirm: the sync client has a built-in upload speed limit; it gets set to half the link. Next morning the upload plateaus comfortably below the ceiling and discards stay at zero. The jitter measurement peaks at 9 ms, and the complaints stop. The longer-term fix is a priority queue for voice at that link, so the next bandwidth-hungry app cannot reoffend. That is exactly the starter QoS design covered elsewhere in this topic.


Notice what the hunt required: two jitter measurements, two interface graphs, and a counter. Nothing exotic. The only expensive ingredient was history — graphs that already existed when the complaint arrived.


The suspect cheat sheet


SuspectFingerprintFirst check
Congestion bursts on a shared linkTracks business rhythm — backups, sync rushes; wired and wireless alike; asymmetric links choke upstream firstUtilization plus out-discards on the bottleneck link at complaint times
Wi-Fi contentionWireless victims only; clusters by location and by how full the office isWired-vs-wireless side-by-side measurement; AP retry rates and client counts
Edge device under loadEveryone through the box affected while links look half idleDevice CPU history against complaint timestamps
Duplex or physical faultOne path, any hour, worse under loadError counters on every port in the path; speed/duplex settings at both ends
Route or path changeLatency steps rather than noise; many users at one exact momentTraceroute during good vs. bad spells; plateau shifts in latency history
The endpoint itselfOne user; follows the laptop, not the desk; network measurements cleanSwap headset and machine; disable power saving; try wired for a day

Where to go next


Keep the compressed version: jitter is waiting. And there are only six waiting rooms — a congested queue, a crowded radio, a busy CPU, a damaged segment, a moving path, and the endpoint itself. Catch the problem while it hurts, bisect with paired measurements, correlate timestamps with counters, and convict by removing the suspect. Most hunts end at suspect one, so the follow-up that pays best is protecting voice from bulk traffic. The rest of the Jitter & Real-Time Traffic guides continue there. They cover buffers, measurement technique, defensible targets, and the starter QoS design that keeps suspect number one from reoffending.


Put this into practice with SysPeep Monitor

Half of diagnosing jitter is having last Tuesday's graphs. SysPeep Monitor collects interface utilization, discards, errors, and device CPU over SNMP and WMI around the clock. So when calls turn robotic you can line the timestamps up against the counters instead of guessing. The free trial installs on a Windows machine in minutes.

Download Free TrialLearn About SysPeep