The Right Questions to Ask When a User Reports Slowness
“The network is slow” sounds like an empty complaint. It is better understood as a compressed one. Somewhere inside it is a real observation. A specific action, in a specific application, at a specific time, is behaving differently from how the user expects. The user is not being vague on purpose; “the network” is simply the name they have for everything between their click and their result. Your job in the first conversation is decompression: pulling the facts out of the feeling.
The instrument for that is not a packet analyzer. It is a short list of questions, asked the same way every time, in an order where each answer sharpens the next. Interviewing is a real technical skill. The user is the only sensor that was present when the problem happened. A good interviewer gets more diagnostic signal from two minutes of conversation than a bad one gets from an hour of tools.
This guide gives you the script: seven questions, why each is phrased the way it is, and what the answers tell you. Then it covers the supporting craft: translating user language into technical hypotheses and walking a user through a reproduction you can measure. It also covers the phrasings that backfire and how to raise the quality of the reports you receive without a whiff of condescension.
In this guide
- Why questions beat tools in the first five minutes
- The seven-question script
- Translating answers into testable facts
- Getting a reproduction you can measure
- Questions that backfire
- Teaching users to report better
- A worked dialogue
- Where to go next
Why questions beat tools in the first five minutes
Tools measure the present; users witnessed the past. By the time you open a terminal, the slow moment may be over. But the user still carries the details of it: what they clicked, what froze, what worked fine at the same time. Questions are also free, instant, and require no access to anything. Most importantly, they aim your tools. A ping test answers a precise question, but only the interview tells you which precise question is worth asking. Otherwise you are measuring the whole network hoping to trip over the answer.
It helps to know what human sensors are reliably good and bad at, because it changes how much weight each answer deserves. Users are excellent witnesses of what they experienced: what they clicked, what the screen did, what worked and what did not, roughly when. They are poor witnesses of magnitude and cause. Durations stretch in memory (ninety seconds with a deadline waiting feels like ten minutes). And “always” often means “twice, both memorable.” Any theory they offer (“I think it's the firewall”) usually echoes whatever IT said during the last outage. So the script asks almost entirely for experiences and timestamps, and treats every offered cause as a lead to verify — never as a fact. Take their observations seriously and their diagnoses lightly, and say thank you for both.
One ground rule before the script: ask to learn, not to confirm. If you already “know” it is the user's Wi-Fi, every question you ask will subtly herd them toward saying so. In that case, users — eager to be helpful, wary of sounding uninformed — will follow your lead. Interview first, hypothesize second. The script below is deliberately ordered to keep your own theories out of the user's mouth.
The seven-question script
Before question one comes a move that is not a question: acknowledge the report. “Thanks for flagging it — let me ask you a couple of things while it's fresh.” One sentence, and the user shifts from complainant to collaborator. Then the script. Ask the questions in order. Each one narrows what the next needs to cover. Write the answers down as you go, in the user's own words. (Your own words will arrive later, and they will be tidier and wrong.) Verbatim notes matter more than they seem. “It moves, just painfully” and “nothing happens for ages” sound interchangeable in memory an hour later. Yet they point at different problems.
1. “What were you doing when you noticed it?”
Open with the story, not a checklist — people answer stories better. You want the concrete action: “opening the monthly report in the finance system,” not “working.” This single answer converts “the network” into a named application and a named task, which is the first coordinate you need. Listen for the verb: opening, saving, loading, joining a call — each implicates a different path and server.
2. “What does the slowness look like on your screen?”
Slow is a feeling; symptoms are facts. A page that stalls and then appears all at once suggests a delay before the server responds. Something that starts fast and grinds mid-transfer suggests throughput or congestion trouble. Video calls that turn robotic point at loss or jitter rather than raw speed. A frozen application window that ghosts white is often the app itself choking, not the network. And a spinning cursor on everything, even local files, is a sick computer. You are not asking users to diagnose, just to describe the picture. They are good at it once asked; the usual problem is that nobody asks.
3. “Is it still slow right now?”
This question forks the whole investigation. Yes means you have a live specimen. In that case, shift into evidence-gathering immediately. Data captured during the event is worth ten times a description after it. That is the whole argument of the slowness evidence kit. No means you are doing forensics: exact times become your most precious facts, and your monitoring history becomes the witness. Either answer is fine; not knowing which mode you are in wastes everyone's afternoon.
4. “Is it just that one thing, or is everything slow?”
Scope, dimension one. Have them try something unrelated while you are on the line — a well-known website, a different internal app. One slow thing amid fast things points at that application or the path to it. Everything slow at once points at the machine or its connection. Users rarely test this on their own; they extrapolate from the one painful thing. Thirty guided seconds here beats an hour of assumption later.
5. “Is anyone near you seeing the same thing?”
Scope, dimension two. A quick shout across the partition, a message to a teammate — either turns one report into a pattern or isolates it to one desk. Both outcomes are useful: shared symptoms move suspicion to shared infrastructure; a lone victim moves it to the local machine. This is the question that most changes what you do next. The full mapping of scope patterns to first moves lives in the first-ten-minutes triage routine.
6. “When did it start — and did anything change around then?”
Get the best timestamp they can offer, then anchor it: “before or after lunch?” beats “a while ago.” Then ask the second half gently and about the machine rather than the person. Ask about updates installed, new software, a moved desk, a new dock or cable, or switching from wired to wireless. Phrase it as “did anything change?” not “what did you do?” — the first invites information, the second invites defensiveness, and a defensive user forgets things. Sudden onset with a nearby change is a completely different investigation from gradual worsening. The distinction is big enough that chronic versus acute slowness gets its own guide.
7. “Can you show me?”
The closer, and the most valuable question on the list. A demonstration — over a screen share or at their desk — replaces every ambiguity of language with direct observation. You see the actual app, the actual delay, the actual error nobody mentioned, the eleven browser windows nobody thought relevant. If the demonstration reproduces the problem, you now own a test case you can rerun after every hypothesis. If it does not, that too is data: the problem is intermittent, and you plan differently.
For remote and home-office workers, append one extra scoping question to the script. Ask: “how are you connected right now, and does anything else at home use that connection?” A neighbor test does not exist in a home office. So its substitutes are the household — someone streaming in the next room, a console downloading a game — and the phone-on-cellular comparison. Remote complaints route through equipment you have never seen and cannot manage, which makes the interview a bigger share of the diagnosis, not a smaller one.
Translating answers into testable facts
Users speak in experience; you test in hypotheses. The translation table gets you from one to the other. Treat the middle column as a starting bet, not a verdict — then confirm with the test on the right:
| What the user says | Probable meaning | Your next test |
|---|---|---|
| “It hangs, then loads all at once” | Wait on server response or name lookup | Time the app vs. a ping to its server |
| “Downloads start fine, then crawl” | Throughput or congestion problem | Check link utilization; test a file copy |
| “Calls sound robotic / video freezes” | Packet loss or jitter, not speed | Sustained ping watching loss and variation |
| “Everything's slow, even opening folders” | The computer itself is struggling | Task Manager: CPU, memory, disk |
| “It's only slow in the mornings” | Load-correlated: shared resource at peak | Compare graphs at good vs. bad hours |
| “It's fine on my phone” | Path-specific: their PC or your network | Second-machine test on the same path |
| “It logged me out and now it's slow” | App session or authentication trouble | Check the app and auth servers first |
Getting a reproduction you can measure
A reproduction is the problem performed on demand — and it converts slowness from an anecdote into an experiment. Once you can trigger the symptom, you can watch every graph and counter while it happens. You can then prove a fix worked by running it again. Getting one is a small procedure of its own:
- 1. Pin the exact action. Not “use the finance system” but “open the Q-report screen, click Export.” Write it down as steps.
- 2. Time it honestly. Count seconds or use a phone stopwatch from click to done. “Forever” is a mood; “forty seconds” is a measurement you can compare after changes.
- 3. Establish the contrast. Ask what that action normally takes, or time a colleague doing the same thing. Slowness only exists relative to normal.
- 4. Note the exact time of the run, so the attempt can be lined up against monitoring graphs and logs later.
- 5. Run it while you watch the telemetry. The payoff move: you stare at the interface graph, the server CPU, the ping window — while they click. Correlation between their click and your graphs is the fastest honest diagnosis available.
- 6. Vary one thing at a time. Same action from the neighbor's PC, from a wired port, from your own desk. Each variation isolates one link in the chain, exactly as the four-zone walk in isolating where the slowness lives prescribes.
Tip: if the problem will not reproduce, do not squeeze the user harder for details they do not have. Set a tripwire instead: ask them to note the exact time and action the very next time it happens — and to tell you that day. One fresh, timestamped sighting beats five foggy memories, and it gives your monitoring history a precise window to interrogate.
Questions that backfire
Phrasing decides whether you get facts or noise. Three failure modes account for most bad interviews. Leading questions plant answers. “Is it slow on Wi-Fi?” invites a yes regardless of reality. “Where were you sitting when it was slow?” retrieves a memory instead. Jargon questions force users to guess at words they do not use. “Is it the LAN or just egress?” produces a guess. That is because you have asked for a translation into a language they do not speak. Blame-scented questions — “what did you install?”, “did you click something?” — make people defensive, and defensive people un-remember the exact detail you need. A few rewrites:
- “Did you reboot?” (accusatory ritual) → “Let's restart it together now and see if the timing changes — that tells me something either way.”
- “Is your VPN acting up again?” (leading) → “How are you connected right now — office network, home, VPN?”
- “Is it latency or bandwidth?” (jargon) → “Does it pause before anything happens, or does it move and just move slowly?”
- “What did you change?” (blame) → “Did the computer update or restart itself recently, or get any new software from anyone — including us?”
That last rewrite carries a secret worth internalizing: “including us.” IT's own patches, policy pushes, and agent updates change more machines than users ever do. Asking in a way that includes your team as a suspect is not just polite — it is accurate.
Teaching users to report better
You cannot lecture people into writing better tickets, and trying reads as condescension. That is the fastest way to make users stop reporting problems at all. This feels quieter and is actually much worse; problems you never hear about never get fixed. What works is quieter: close the loop. When a user's detail cracks the case, tell them so. Say: “Your note that it started right after the update was the key — that is what it turned out to be.” People repeat what gets praised. Within a few cycles, your best reporters are training the room for you.
The other half of the same rule: never make a report feel foolish. This holds even for the ones that turn out to be the user's own machine, and even when it is the fourth time this month. The user who gets an eye-roll files their next problem with nobody, and the next problem might be the early warning of something big. A cheerful “good news, it was just the laptop this time — here's what to watch for” keeps the sensor network you actually depend on switched on. Vague reports are not a user failing; they are the raw material of the job.
At Harbourview Clinic the reception desk reported “the network is slow” three times in one month. Three times the answer was “works fine from here,” which was true, from the server room. After the third, the receptionist stopped reporting it. The uplink from the reception switch had been dropping packets for weeks, and it failed on a Monday morning with a full waiting room. The report that would have caught it in time was the fourth one, and the fourth one was never filed.
The other lever is making the good report effortless. Give people a tiny template — in the ticket form, on the intranet, pinned in the help channel. Five lines, no jargon:
When it happened: (date and time, as exact as you can) What I was doing: (which app, which action) What I saw: (froze / crawled / error message / robotic audio) How wide it is: (just this app or everything? anyone nearby too?) How I'm connected: (office wired / office Wi-Fi / home / VPN)
Notice the template is simply your seven-question script with the questions pre-asked. Every field a user fills in is an interview minute you do not have to spend. It is also a fact captured minutes after the event instead of days. Keep it to five lines. Every field you add past the essentials halves the chance anyone fills it in at all. A half-completed short form still beats a blank long one.
A worked dialogue
Here is the script in the wild, trimmed to its spine. User: “The network's been awful all morning.” You: “Sorry about that — what were you in the middle of when you noticed?” User: “Uploading photos to the product catalog. It's taking forever.” (One app, one action, an upload — already a direction.) You: “What does it look like — does it start and crawl, or stick at zero?” User: “It moves, just painfully.” (Moving-but-slow: throughput, not a stall.) You: “Is it still like that right now? And is normal browsing okay?” User: “Yes, and… yeah, websites seem fine.” (Live problem; scoped to uploads rather than everything.) You: “Anyone nearby uploading too, or seeing slowness?” User: “Marta says downloads are fine but her sync thing is stuck.” (Second victim, same direction: upload path.) You: “Great, that helps a lot. Can you start one more upload for me right now while I watch the graphs?”
Ninety seconds of talk, and the shapeless “network's awful” has become: upstream transfers are slow building-wide, downstream looks normal, reproducible on demand. A glance at the internet link's upstream graph during the test upload finishes the isolation while the user is still on the line. The graph is pinned flat at the top. What filled it (a runaway offsite backup, as it often is) is the next investigation, but every minute of it is aimed. That is because the interview did its job.
Where to go next
Seven questions, a translation table, and a reproduction procedure: that is the whole interviewing kit. It upgrades every other tool you own by pointing them at the right target. The ticket will still say “the network is slow.” It always will. The difference is that you now know what it is compressing, and how to unpack it in two minutes without making anyone sorry they filed it. From here, run the answers through the first-ten-minutes triage routine if you have not already. Isolate the layer with the four-zone method, and capture what you find while it is fresh. The full set of guides lives at “The Network Is Slow”: A Diagnostic Playbook.
Put this into practice with SysPeep Monitor
The best moment in any user interview is "can you show me?" — you watching the graphs while they click. SysPeep Monitor gives you those graphs: live interface, server, and link metrics collected over SNMP and WMI. They appear on one dashboard you can keep open during the conversation. The free trial installs in minutes on a Windows machine.
Download Free TrialLearn About SysPeep