Home › Topics › It's Always DNS: Name Resolution Health › Proving It Isn't DNS

Proving It Isn't DNS (This Time): Fast Exoneration Tests


The meme cuts both ways. "It's always DNS" earns its laughs because name resolution really does cause a spectacular share of mystery outages. But the same reputation makes DNS the default suspect in every incident, including the majority where it is completely innocent. So the investigation stalls in the usual place. Someone says "probably DNS." Someone flushes a cache. Someone bounces a DNS service that was fine. And twenty minutes evaporate while the actual broken thing sits untouched.


The professional move is to settle the question instead of debating it. DNS has a rare and wonderful property among suspects: it can be conclusively tested in minutes, from the affected machine, with tools that are already installed. A short battery of checks either implicates name resolution or clears DNS with evidence. If it implicates name resolution, you have found your problem and can march down the troubleshooting playbook. If it clears DNS, the investigation is free to hunt where the fault actually lives.


This guide is that battery. It includes four quick tests and a decision table that turns their outcomes into a verdict. It includes a template for writing the exoneration into the ticket so the question stays settled. A final section covers the sneaky cases where "not DNS" really means "the thing DNS depends on."


In this guide

  • Why proving the negative is worth ten minutes
  • The battery at a glance
  • Test 1: Name versus IP
  • Test 2: Resolution timing, on the spot
  • Test 3: Every resolver, individually
  • Test 4: Bypass the caches
  • The decision table: from outcomes to verdict
  • Writing the negative result into the ticket
  • When "not DNS" means "the thing DNS depends on"
  • Where to go next

Why proving the negative is worth ten minutes


Unfalsified suspicion is expensive. While "probably DNS" hangs in the air, it anchors everyone's thinking. The server team waits for the network team. The network team gestures at the domain controllers. Nobody commits to a direction because the comfortable suspect hasn't been ruled out. Ruling it out — explicitly, with commands and outputs — does two things at once. It releases the investigation to go find the real cause. It spares the DNS infrastructure another round of superstitious service restarts. Each restart resets caches and makes the real picture harder to read.


There is also a career-shaped reason. "It's not DNS" said with a shrug is an opinion, and opinions get re-litigated every hour of a long incident. "It's not DNS, here are the four tests and their outputs" is a finding. Findings stick. The general craft of turning quick checks into blame-proof evidence is covered in exoneration evidence. This article is the DNS-specific edition, tuned so the whole exercise fits inside ten minutes.


One more cost of skipping the proof: superstition compounds. When someone restarts a DNS service mid-incident and the problem happens to clear, the restart gets the credit. It may have cleared because a cache expired, a server came back, or a user retried. But the team's mental model of the network gets a little more wrong. Next incident, the ritual repeats earlier and with more confidence. Recorded negatives are how you break the loop. The day the ticket says "DNS tested clean at the time of the restart," the ritual loses its magic. Future incidents start from evidence instead of folklore.


The battery at a glance


Four tests, in order, each answering one question:


  • 1. Name versus IP — is the failure about finding the server or reaching it?
  • 2. Resolution timing — are lookups fast, or is a slow resolver taxing every connection?
  • 3. Every resolver, individually — do all the servers clients rely on agree, quickly?
  • 4. Cache bypass — is the current, fresh answer correct, independent of anything remembered?

Run them from the affected machine wherever possible — a healthy result from your admin workstation proves your workstation is healthy, which nobody doubted. If the affected machine is unreachable, run them from the same network segment and say so in your notes. The perspective you test from is part of the finding.


Before you type anything, collect three inputs. First, get the exact failing name, copied from the error or a screenshot, not paraphrased. An honest fraction of "DNS failures" turn out to be typos, stray spaces, or the wrong hostname entirely. Second, get the resolver IPs the machine is configured with. Third, if you can get it, find one nearby machine where the same action works. The working neighbor is your control group: any test that differs between the two machines has just told you where to dig. With those in hand, the battery itself is mostly copy, paste, and read.


Test 1: Name versus IP


The oldest split in troubleshooting: separate the phone book from the road. Resolve the name, then test reachability to the resolved address directly:


C:\> nslookup files.corp.example
Name:    files.corp.example
Address: 10.20.4.60

C:\> Test-NetConnection 10.20.4.60 -Port 445
TcpTestSucceeded : False

This example is already a verdict. The name resolved instantly and correctly — DNS did its entire job — and the connection to the resulting address fails anyway. Whatever is wrong lives at the server or on the path to it, not in name resolution. Conversely, if the name won't resolve while the IP connects fine, DNS is implicated and your ten minutes are over early. In that case, switch guides to the playbook.


Prefer a port test over a bare ping when a specific service is the complaint. Ping proves the road exists, while a port test proves the door opens. And hosts answer ping with the service dead often enough to embarrass anyone who stops at ping. Two caveats keep this test honest. Some hosts block ping and some paths block it selectively, so treat "ping fails" as weaker evidence than "port test fails." And browsing to a website by raw IP frequently fails even when everything is healthy. Web servers host many names on one address and need the right name to serve the right site. So for websites, use the IP only for reachability, never as proof the site itself works.


Test 2: Resolution timing, on the spot


DNS doesn't have to fail to be guilty; it can also be slow, taxing every fresh connection with seconds of stall while still technically working. Users experience this as "everything is sluggish," and it never shows up in a test that only asks whether resolution succeeded. So measure it:


PS C:\> Measure-Command { Resolve-DnsName files.corp.example }

TotalMilliseconds : 2.41

A couple of milliseconds is a cached answer from a healthy LAN resolver — DNS exonerated on the speed charge. A result in the seconds, or a first run that crawls while a second run is instant, tells a different story. It is the classic pattern of a dead first resolver. In that case, every uncached lookup burns a timeout before the second server rescues it. That is a real DNS finding (a degraded one rather than an outage), and it reliably masquerades as network or application slowness. Run the measurement two or three times and note both the cold and warm numbers; the pair tells you more than either alone.


Keep the stopwatch honest about what it times. This command measures resolution only, deliberately. A fast result here alongside a slow application separates "finding the server" from "talking to the server." Test 1 separated finding from reaching the same way. And remember that browsers keep their own small DNS caches and connection pools on top of the operating system's. So a user's experience can lag behind what your freshly run command shows. When the two disagree, a browser restart is part of the test, not an admission of defeat.


Test 3: Every resolver, individually


Client machines quietly fail over between their configured resolvers, which means "resolution works" can be true while half your resolver pair is dead or deranged. Exoneration requires checking each server the client depends on, directly and by IP. Get the list from ipconfig /all, then ask each one the same question:


C:\> nslookup files.corp.example 10.10.8.21
Name:    files.corp.example
Address: 10.20.4.60

C:\> nslookup files.corp.example 10.10.8.22
Name:    files.corp.example
Address: 10.20.4.60

You want two things: agreement and speed. Both servers returning the same answer promptly clears the resolver layer entirely. One server failing, lagging, or — most interesting — returning a different answer is a genuine DNS lead even if the user's immediate problem lies elsewhere. Disagreement between servers that should hold identical data means stale zone copies or replication trouble. It will cause its own incident soon enough. Log it either way. An exoneration that notices a separate smoldering problem is a good day's work.


One subtlety: make sure you are testing the resolvers the failing traffic actually used. A laptop can have several DNS personalities at once: the wired adapter's servers, the wireless adapter's, and a VPN adapter's. Each list can differ, with the operating system choosing by adapter and destination. The user who "can't reach anything internal" on VPN may be resolving through their home router while your tests sail through the corporate list. ipconfig /all shows every adapter's servers. Test the set that matches the complaint, or you are exonerating the wrong suspect with great confidence.


Tip: keep the whole battery as a paste-ready block in your notes app — four commands with placeholders for the name and resolver IPs. Under incident pressure, the difference between "I could run some tests" and "I ran the tests, here's the paste" is about ninety seconds and a great deal of credibility.


Test 4: Bypass the caches


The first three tests can all be fooled by one thing. That is a cached answer, served from memory at any layer, that no longer reflects reality. The final test asks for the truth as it exists right now. Two moves, thirty seconds:


# Move 1: clear the client's memory, ask again
C:\> ipconfig /flushdns
C:\> nslookup files.corp.example

# Move 2: ask the zone's own server, bypassing every resolver
$ dig corp.example NS +short
dc1.corp.example.
dc2.corp.example.
$ dig @dc1.corp.example files.corp.example +noall +answer
files.corp.example.   3600   IN   A   10.20.4.60

Move 1 rules out a stale or negative entry on the complaining machine. Move 2 goes over the heads of every cache and forwarder to the authoritative source: the servers that own the zone. The test reads the record at the counter. When the fresh client answer, both resolvers' answers, and the authoritative answer all match, the caching layers are provably telling the truth. In that case, the last DNS hiding place is closed. If they don't match, you've caught the rare and satisfying "cached lie" in the act. In that case, note which layer disagrees, because that is precisely where the playbook should start.


There is a bonus variant for timing the uncached path. Query a name that cannot possibly be in any cache, such as a made-up label under a zone you control (test-probe-xyz.corp.example). The answer will be a prompt "does not exist" — which is fine, because you're not after the answer. You're after the round-trip. An NXDOMAIN can only come back after the resolver has genuinely consulted the source. So its arrival time measures the live, cache-free path. Fast NXDOMAIN, healthy chain; slow or absent NXDOMAIN, and the sluggishness users report is real and lives upstream. Use your own zone for this — aiming streams of invented names at other people's domains is poor manners.


The decision table: from outcomes to verdict


Now convert outcomes into a ruling. Find your row:


What you foundVerdictNext move
Name fails to resolve; IP reachableDNS implicatedStop exonerating; run the troubleshooting playbook from step 2
Name resolves correctly and fast everywhere; port/IP test failsNot DNSInvestigate the server, its service, and the network path; attach the evidence
Name and IP both unreachableNot DNSConnectivity or the host itself; hand the network team your outputs as a head start
Resolution succeeds but takes seconds, or cold lookups crawlDNS degradedCheck the first-listed resolver — a dead or sick first entry taxes everything
Resolvers disagree with each other or with authoritativeDNS data problemStale zone copy, replication, or negative caching; playbook step 5 territory
Everything passes, but only some machines are affectedClient-sideCompare caches and hosts files on a broken versus working machine

Two rows deserve a second look. The "DNS degraded" row is the one most often missed in real incidents, because every individual test succeeds — only the stopwatch catches it. And the last row is why you ran the battery from the affected machine. A fault that follows the machine rather than the name is a different investigation with a much smaller search area.


Writing the negative result into the ticket


An exoneration that lives only in your terminal history will be re-asked in an hour. Spend three minutes making it permanent. A good negative result names the time, the vantage point, the tests, and the verdict — compact enough to paste whole:


DNS exoneration — files.corp.example — from PC-114 (10.10.30.44)

1. Resolution: files.corp.example -> 10.20.4.60 on BOTH
   resolvers (10.10.8.21, 10.10.8.22); ~2 ms each
2. Timing: cold lookup 2.4 ms — no resolver stall
3. Cache bypass: post-flush answer and authoritative answer
   (dc1) both 10.20.4.60 — caches truthful
4. Reachability: TCP 445 to 10.20.4.60 FAILS from client subnet

Verdict: name resolution correct, fast, and consistent.
Fault is at the file server or the path to it. DNS exonerated
for this incident.

Notice what the format does. Each line pairs a claim with its observed value, so a skeptic can re-run any single check rather than reopening the whole question. The verdict says what is implicated, not just what isn't — an exoneration should hand the baton to the next runner, not drop it. And the vantage point is explicit, because "from where" is the first thing a sharp colleague will ask. File it in the ticket, not in a chat scrollback; tickets are where the next shift looks.


If you run resolver monitoring, cite it here too. The sentence "per-resolver checks green throughout the incident window" carries a week of minute-by-minute evidence. It pairs beautifully with the on-the-spot tests. The monitoring proves DNS was healthy over time. The battery proves it is healthy from this vantage point right now. Between them, the question is closed from both directions.


When "not DNS" means "the thing DNS depends on"


One twist keeps this subject humble. DNS is a service running on servers, over a network, configured by DHCP, and fed by upstreams. When any of those fail, the symptoms wear a DNS costume. Your battery says "resolver unreachable," and that's true, but the root cause sits one layer down:


  • The path to the resolver. A switch, VLAN, or firewall change strands clients from UDP port 53. Every lookup times out; the resolver is fine and lonely.
  • DHCP handing out the wrong resolvers. A scope edited in haste or a rogue DHCP server points clients somewhere useless. Machines break as their leases renew — a slow-rolling "DNS outage" no DNS server caused.
  • The resolver's host. The VM host dies, the disk fills, the box is mid-patch: the DNS service is a victim of ordinary server trouble.
  • The upstream provider. Your forwarders' target has the bad day; your servers dutifully relay SERVFAILs they didn't earn.
  • An expired domain registration. The rare but unforgettable one: a domain nobody renewed simply vanishes from the internet's delegation. No amount of server-side heroics resolves a name the world no longer delegates.

So the honest final verdict is sometimes "DNS is the messenger, not the culprit." Getting from the costume to the cause is a matter of following the dependency chain one link at a time. The links are the resolver's host, its network, its configuration source, and its upstream. This is exactly the discipline dependency thinking teaches. It is exactly why a debuggable resolver architecture keeps those links few and visible.


Where to go next


Ten minutes, four tests, a verdict, and a paper trail: that is the whole craft of clearing the network's favorite suspect. Run the battery enough times and you will notice the deeper win — incidents stop starting with a debate. Either DNS did it, and the playbook takes over with the fault already localized. Or it didn't, and the real investigation begins immediately with evidence in hand. To make the battery largely unnecessary, wire up the per-resolver checks in Monitoring DNS Health. Then the answers are already on a dashboard when the ticket arrives. The full series lives at It's Always DNS: Name Resolution Health.


Put this into practice with SysPeep Monitor

Exoneration is fastest when the history already exists. SysPeep Monitor watches your resolvers' hosts and the paths to them. It watches reachability, Windows service health over WMI, and resource metrics over SNMP and SSH. So "what was DNS doing when this started?" is answered by a graph instead of a shrug. Dependency-aware alerts point at the failing layer by name, and the free trial installs on one Windows machine.

Download Free TrialLearn About SysPeep