Five Solved Cases: Real Diagnoses From Real Captures
Every guide in this pillar teaches a skill in isolation: when to capture, where to stand, which filter, how to read the flags. This one is different. It is the case file drawer — five investigations told start to finish, the way they actually unfold. Each begins with a vague complaint, graphs that almost help, and a decision about where to capture. Then comes the moment every packet person lives for: the handful of lines on screen that end the argument.
The five cover the classics you will meet in your own career. They include the slow application that "must be the network," calls that die mid-sentence, and a backup that fails on schedule. There is a DNS fault that gaslights half the office. And — because it is always eventually the printer — there is a printer. Read them for the verdicts, but more for the shape of the reasoning, because the shape is the transferable part.
In this guide
- How to read these case files
- Case 1: the slow app that wasn't the network
- Case 2: the dying phone calls
- Case 3: the backup that failed at the same point every night
- Case 4: the DNS mystery
- Case 5: the printer, of course
- The pattern behind all five
How to read these case files
Each case follows the same five beats, and the repetition is deliberate — it is the method wearing five different costumes:
- The complaint — what humans reported, in their words.
- What the graphs said — and why the usual evidence was not enough. Monitoring metrics and flow data answer most questions cheaply; captures are the escalation for the questions they cannot reach. (Choosing that escalation moment well is its own skill — see when to reach for packet capture.)
- Where we captured, and why — because vantage decides what a capture can prove. The mechanics of mirror ports, taps, and host captures live in SPAN, mirror ports, and taps.
- The tell — the smoking-gun packets, quoted and annotated.
- The fix, and the lesson — what changed, and the one line worth keeping.
Note: these are composites — details merged and renamed from many networks, because real captures are confidential (a principle with its own guide in this pillar). But every tell shown here is the genuine article: these are exactly the patterns that appear on screen when you meet each problem yourself.
Case 1: the slow app that wasn't the network
The complaint. "The network is slow." Specifically: the order-lookup screen in a line-of-business app took eight to ten seconds to load, all day, for everyone. It used to be instant. The application team had already inspected their servers and pronounced them healthy, so the ticket arrived with the diagnosis pre-written: network.
What the graphs said. Nothing incriminating. Links at comfortable utilization, ping to the app server around a millisecond with no loss, interface counters clean. But clean graphs cannot acquit the network in the user's eyes, because graphs measure links, not experiences. They cannot say where an individual request's eight seconds went. Only the wire can split that time honestly.
Where we captured. A mirror of one affected user's switch port — the victim's-eye view. If the delay was on the network path, we would see it as gaps, retransmissions, or slow handshakes from the user's own vantage point.
The tell. We reproduced one slow lookup, filtered to the app conversation. The time column was set to show the delta from the previous packet. This is the single most valuable column setting in Wireshark — see Wireshark fundamentals:
No. Delta From To Info 115 0.000000 pc-lena app01 [SYN] connection opens... 116 0.000922 app01 pc-lena [SYN,ACK] ...in about 1 ms. Network fine. 118 0.000108 pc-lena app01 [PSH,ACK] len 642 the lookup request leaves 119 0.000431 app01 pc-lena [ACK] server: "received." (0.4 ms) 120 8.204112 app01 pc-lena [PSH,ACK] len 5793 the answer -- 8.2 seconds later 121 0.000389 pc-lena app01 [ACK] transfer itself: instant
Packet 119 is the whole case. The server acknowledged the request within half a millisecond — delivery confirmed, network done, gavel down. Then the wire went silent for 8.2 seconds: no retransmissions, no window trouble, nothing in flight. That silence is the server thinking. When the answer finally came, it crossed the network in a blink. For contrast, picture what a guilty network would have looked like from the same chair. There would be a handshake taking seconds, the request retransmitted, duplicate ACKs, and gaps mid-transfer while TCP repaired losses. None of that is here — the wire is quiet because the wire was finished.
The fix. The capture was handed to the application team. The mystery moved indoors within a day. A database query behind that screen had quietly lost its index after a schema change and was table-scanning on every lookup. Index restored, screen instant again, network formally exonerated.
The lesson: the wire is the referee. An ACK timestamp separates "network time" from "server time" with sub-millisecond honesty, and no amount of opinion survives contact with packet 119.
Case 2: the dying phone calls
The complaint. A branch office's calls turned robotic or dropped — a few per day, mostly afternoons, never reproducible on demand. The phone vendor blamed the network; the previous admin had blamed the phones; the users blamed everyone.
What the graphs said. The branch uplink peaked around half capacity on the five-minute graphs. And that is the trap: a five-minute average is a smoothie — a two-second burst that murders a phone call vanishes into it completely. Voice suffers in seconds; the graphs report in minutes. The evidence had the wrong shutter speed.
Where we captured. We mirrored the branch uplink into a ring-buffer capture, left running for days. The voice system's own quality alarms noted timestamps for us. Both suspects — voice packets and everything competing with them — had to be in the same recording, on one clock, or nothing could be proven. And because the fault would not perform on command, this was a stakeout rather than a session. The capture had to already be running when the moment came. That is exactly the ring-buffer discipline from catching the intermittent.
The tell. At an alarm timestamp, the two schedules collide on screen:
14:07:31.020 phone-14 > pbx: RTP audio, 214 bytes (every 20 ms, like a metronome)
14:07:31.040 phone-14 > pbx: RTP audio, 214 bytes
14:07:31.041 bkp02 > hq-store: seq 8840120:8841568, len 1448 (replication burst begins)
14:07:31.041 bkp02 > hq-store: seq 8841568:8843016, len 1448
... a wall of full-size segments, then their retransmissions ...
14:07:31.128 phone-14 > pbx: RTP audio, 214 bytes (68 ms late; three packets never arrived)
The voice stream ticks along in tidy 20-millisecond steps — until a server at the branch begins blasting bulk replication toward headquarters. It blasts hard enough that its own segments are being lost and retransmitted. The burst and its echoes flood the uplink queue. During each burst, voice packets queue behind the flood, arriving late or not at all. Sixty-eight milliseconds of gap is an eternity mid-syllable.
The fix. The bulk job belonged to the night. A failed overnight run had left it in a retry loop that fired again in the afternoon. And the uplink's quality-of-service policy, everyone was surprised to learn, had never actually been applied to that port. Job rescheduled with its retry window fenced, priority queueing for voice verified with a follow-up capture. The robots stopped calling.
The lesson: timing correlation is the capture's superpower — two innocent-looking schedules, overlaid on one packet timeline, become one obvious collision.
Case 3: the backup that failed at the same point every night
The complaint. The nightly backup to a NAS (network-attached storage box) died every night, forty-odd minutes in, with the same log line: network error — connection reset. Same offset, every night, like clockwork — which is already a clue, because genuine network gremlins are rarely punctual.
What the graphs said. A beautiful steady transfer plateau, then a cliff at the moment of death. Switch counters spotless: no errors, no discards, no link flaps. The log said "network error"; the network's own bookkeeping said "delivered everything I was given." Somebody was wrong, and graphs alone could not say who.
Where we captured. On the backup server itself — a host capture, filtered to the NAS conversation. When an application accuses the network, capture at the accuser. You record exactly what its TCP stack experienced, including everything the "network error" actually consisted of. (Had the capture shown data sent and never acknowledged, the follow-up would have been a second capture at the NAS end. That would show whether it ever arrived. But one vantage turned out to settle this one.)
The tell. Here is the final minute of the transfer, reading like a slow-motion plea. The grammar of windows and resets is covered in reading a TCP conversation like a story:
01:47:12.881 nas.445 > bkp.49821: [ACK] win 168 (NAS's window shrinking...) 01:47:12.930 nas.445 > bkp.49821: [ACK] win 34 (...and shrinking...) 01:47:13.002 nas.445 > bkp.49821: [ACK] win 0 "stop -- I'm full" 01:47:13.512 bkp.49821 > nas.445: window probe "room yet?" 01:47:13.513 nas.445 > bkp.49821: [ACK] win 0 "no." (and so on, for 41 seconds) 01:47:54.216 bkp.49821 > nas.445: [RST] the backup's patience runs out
Not one packet was lost. The NAS advertised a shrinking receive window, then hit zero — TCP's completely legal "stop talking, I cannot absorb more". It stayed at zero for forty-one seconds while its cache flushed to slow, nearly full disks. Its own diagnostics later confirmed that. The punctual offset was the cache filling at the same point in the data every night. The backup software's application timeout was shorter than the pause, so it slammed the door and then blamed the network in its log.
The fix. Storage-side housekeeping on the NAS (freeing space and rescheduling its internal maintenance) plus a more patient timeout in the backup job. The transfer's forty-minute mark passed quietly that night and every night after.
The lesson: TCP's flow control names the party that couldn't cope. When a transfer dies, find who advertised win 0 — the wire records exactly who asked for mercy, and for how long.
Case 4: the DNS mystery
The complaint. Intermittent "cannot reach server" errors in a core app — some machines, some days; clicking retry usually worked. Weeks of low-grade misery: NICs swapped, Wi-Fi blamed, one PC ritually reimaged. Nothing stuck to the wall.
What the graphs said. Everything relevant was green. The app server was healthy. The DNS (Domain Name System — the name-to-address lookup service) server was healthy and answering fast. Which is precisely why the failures felt supernatural — every component being monitored was innocent. The guilty party was not on the dashboard at all.
Where we captured. On one afflicted PC, filtered to DNS traffic, left running until the user hit the error and noted the time. Small, targeted, victim's-eye — a five-minute setup.
The tell. Side by side, a healthy lookup and the moment of failure:
14:02:11.204 pc-31 > 10.4.0.10.53: A? app.internal.example.
14:02:11.205 10.4.0.10 > pc-31: A 10.4.5.20 (correct answer, 1 ms)
...
14:07:31.812 pc-31 > 10.4.0.11.53: A? app.internal.example. (a DIFFERENT server?)
14:07:31.980 10.4.0.11 > pc-31: A 10.4.5.9 (an address retired long ago)
The PC was asking two DNS servers — the real one, and 10.4.0.11, which nobody could immediately name. It turned out to be an old domain controller, half-decommissioned but still running a DNS service with a stale copy of the zone. It was still listed as the second DNS server in one VLAN's DHCP scope, a leftover option nobody had touched in ages. Clients that happened to query the ghost got a dead address for the app and failed. The retry usually asked the healthy server and worked. And why did pc-31 trust the ghost at all? Because DHCP had been handing out that server list all along, exactly as configured. The documentation said every client used 10.4.0.10. The packets said otherwise, and packets do not go stale.
The fix. Corrected the DHCP scope option, shut down the ghost's DNS service properly, and flushed caches. The supernatural failures ended the same afternoon.
The lesson: a capture shows the configuration actually in use, not the one in the documentation. And when the two disagree, only one of them is generating your tickets.
Case 5: the printer, of course
The complaint. Everything on one office VLAN felt sticky — shares slow, apps laggy — and, almost as an aside, "the big printer's queue is stuck again."
What the graphs said. This time the graphs did their job. The print server's gigabit port was pinned near line rate, continuously, which for a print server is deranged. Graphs could name the talker but not the content — what could a print server possibly be saying at a gigabit for hours? That question is exactly the capture's jurisdiction.
Where we captured. Mirror of the print server's port, sixty seconds, no filter needed — when a port is saturated, whatever fills it will dominate any sample.
The tell. One conversation was the entire flood:
11:40:02.113 prnsrv.49188 > mfp3.9100: [PSH] len 1460 "@PJL JOB ..." (a print job begins) 11:40:02.114 mfp3.9100 > prnsrv.49188: [RST] printer slams the door 11:40:02.118 prnsrv.49190 > mfp3.9100: [SYN] spooler tries again, instantly 11:40:02.121 prnsrv.49190 > mfp3.9100: [PSH] len 1460 same job, same bytes 11:40:02.122 mfp3.9100 > prnsrv.49190: [RST] (repeat, at wire speed, forever)
One job — readable right in the payload as a two-page seating chart for an office move — contained something the printer's firmware refused to swallow. It reset the connection a few kilobytes in, every time. The spooler, configured to retry failed jobs and equipped with no delay between attempts, resubmitted it immediately. And again. All day it went: connect, send, slam, connect. It was a photocopier of futility saturating a gigabit port with the same seating chart. Meanwhile, every legitimate job queued behind the jam and the VLAN's switches carried the storm. That also explained the sticky VLAN. The flood shared uplinks and switch queues with everyone's ordinary traffic. So one printer's tantrum taxed the whole neighborhood.
The fix. We deleted the cursed job (queue drained in minutes) and updated the printer's firmware. We gave the spooler a retry delay so one bad document could never again become a denial-of-service appliance. The seating chart was reprinted from a different application without incident, attended by more ceremony than any two-page document deserves.
The lesson: sometimes the microscope finds comedy. The capture cannot promise you a dignified culprit — only the true one.
The pattern behind all five
Line the cases up and the same silhouette appears in each. There is a hypothesis first — not "capture everything and stare," but a question sharp enough to be answerable. Where do the eight seconds go? What shares the wire with voice at failure time? Who ends the backup connection? Which server answers the failing lookups? What is the print server saying? Then the right vantage, chosen so the answer must appear in frame. Then a small, filtered capture — every verdict above came from minutes of packets, not gigabytes of haystack. And each time, one decisive artifact: an ACK before a silence, two schedules colliding, a win 0, a ghost's answer, a job on repeat. Not a mountain of evidence — one exhibit that ends the argument.
Notice also what none of the five required: no exotic tooling, no protocol wizardry beyond this pillar's basics. Handshake timing, an ACK before a silence, receive windows, resets, a DNS answer, a job on repeat — every tell here is readable with the fundamentals. That holds provided the capture was taken in the right place, with the right question, and kept small enough to actually read.
Here is the closing invitation: start your own case file. The next time a capture settles something — however small — write it up in the five-beat shape while it is fresh. The beats are complaint, graphs, vantage, tell, fix, lesson. Ten minutes. A year later you will own two compounding assets. One is a private pattern library that makes every new mystery feel familiar. The other is a reputation as the person who does not argue about what happened — the person who shows what happened. The supporting skills cover every beat: deciding, standing, filtering, reading, staking out, and handling the files responsibly. They are all waiting in the Packet Capture & Analysis pillar.
Put this into practice with SysPeep Monitor
Notice what opened every case here: a graph, a counter, or an alert that pointed somewhere specific. SysPeep Monitor supplies that first half of the method. It watches your devices, interfaces, and services around the clock. It keeps the utilization and error history, and alerts you with timestamps you can carry straight into a capture. The packets close the case; good monitoring tells you which case to open. The free trial installs on a Windows machine in minutes.
Download Free TrialLearn About SysPeep