Home › Topics › It's Always DNS: Name Resolution Health › Resolver Architecture

Resolvers, Forwarders, and Caches: DNS You Can Actually Debug


Some DNS setups are a pleasure to troubleshoot. A check fails. You glance at the layout. The fault can only live in one of two places. Five minutes later you're writing the fix. Other setups are archaeology. Nobody remembers why the print server is also a resolver. Half the clients point at a firewall that forwards to who-knows-where. Every outage begins with an hour of discovering your own network. The difference is not luck or budget. It is architecture — and for DNS, good architecture mostly means debuggable architecture.


This guide lays out a reference design for a small or mid-sized organization — the kind typically built around Active Directory. Just as importantly, it explains why each layer exists and what each layer's failure looks like from a user's chair. Then we tour the classic mistakes. These include the single resolver, the clients pointed at random public servers, the forwarding loop, and the other traps that turn a five-minute diagnosis into an afternoon. You need no prior architecture experience, just the mental model of the resolution chain from Why It's Always DNS.


In this guide

  • Three jobs one server can hold
  • The reference layout for a small organization
  • Why layering matters when things break
  • Redundancy done right: two resolvers clients actually use
  • The classic architecture mistakes
  • Forwarders versus root hints: an honest tradeoff
  • Designing for loud, localizable failure
  • An architecture health checklist
  • Where to go next

Three jobs one server can hold


Much of DNS's reputation for confusion comes from one fact: three genuinely different jobs are usually performed by the same box, under the same name. Pull them apart once and the fog lifts:


  • Authoritative server. Owns zone data — the actual records for corp.example — and answers questions about those zones with the final word. It doesn't need to know anything about the rest of the internet.
  • Recursive resolver. Answers any question on behalf of clients, doing whatever legwork it takes — chasing referrals from the root servers down to whoever is authoritative. Clients ask it one question; it does the whole hunt.
  • Cache. The memory both of the above keep of recent answers, so repeat questions cost nothing. Caching is a behavior rather than a role, but it has its own failure modes — stale and wrong — so it earns a seat at the table.

A domain controller running the DNS role typically performs all three at once. In that typical setup, it is authoritative for your internal zones, resolver for everything else, and cache for whatever passed through. Add the forwarder configuration — "for questions I can't answer, don't do the hunt yourself; hand them to this specific upstream server" — and you have the complete vocabulary. When you debug, you are always asking which job failed, not just which box. The same server can be a perfectly healthy authoritative while being a broken resolver, and vice versa. You will meet this split constantly. A domain controller whose forwarder target vanished is a broken resolver — external lookups fail. It remains a flawless authoritative for your zones, so internal names keep working and the outage feels "weird" rather than "DNS." That single distinction explains half the "but it answers some things!" mysteries in the trade.


The reference layout for a small organization


Here is the boring, excellent design that fits the overwhelming majority of small and mid-sized networks:


workstations, servers, printers, everything
      |                    |
      |  (DHCP hands every client BOTH)
      v                    v
+--------------+    +--------------+
|    dns1      |    |    dns2      |   internal resolvers
| (AD DNS role)|    | (AD DNS role)|   authoritative for corp.example
+--------------+    +--------------+   forwarders for the rest
       \                  /
        v                v
   upstream resolvers: 198.51.100.11, 198.51.100.12
   (your provider's, or a public service)
        |
        v
   the rest of the internet

Reading it top to bottom: every client gets both internal resolvers from DHCP, and only those two. There are no exceptions, no "backup" public entries (a trap with its own section below). The two internal servers hold identical copies of your zones, courtesy of Active Directory replication. They carry identical forwarder settings pointing at a pair of upstream resolvers. Internal questions are answered on the spot, authoritatively. External questions flow up through exactly one well-known doorway.


The virtues are quiet but real. Every client behaves the same way, so one user's experience predicts everyone's. Internal resolution keeps working even when the internet link is down. Logons, printers, and file shares don't care that the upstream is unreachable. All external dependence is concentrated in one visible place instead of smeared across every device's settings. And the whole thing can be drawn from memory on a whiteboard. That sounds like a joke criterion until the day you are troubleshooting at 2 a.m. If the layout can't be drawn, it can't be debugged.


Where Active Directory fits in

In a Windows domain, DNS is not merely used by Active Directory — it is how AD finds itself. Domain controllers advertise their services by registering SRV records (service-location records) in the domain's zones. Every client locates a controller for logon by looking those records up. Controllers also look them up to locate each other for replication. This is why the reference layout runs the DNS role on the domain controllers with AD-integrated zones. The zone data replicates automatically with the directory itself. Both resolvers stay authoritative and identical without any extra transfer plumbing. And domain-joined machines can register their own records securely. It is also why the "clients use internal resolvers only" rule is not a style preference. A machine pointed elsewhere cannot find the SRV records. The resulting symptoms — slow or failed logons, group policy not applying, trust errors — look like anything except a DNS setting.


Branch sites

A small branch office adds one decision: where do its clients resolve? Pointing them across the WAN at headquarters is simplest and fine for a handful of users. But every lookup rides the WAN. A link outage takes the branch's name resolution — and therefore its logons — down with it. The sturdier pattern for a real office is a local resolver (often a branch domain controller) holding the same zones, forwarding upward like everything else. Whichever you choose, apply the same rules as at HQ. Clients get resolvers from DHCP. The layout appears on the diagram. And the branch resolver is monitored from both sides of the WAN so "the branch is slow" has a chart to consult.


Why layering matters when things break


The payoff of clean layers is that each one is independently testable, and each one's failure produces a distinct signature. That turns troubleshooting into a quick binary search instead of a fog-of-war expedition:


What brokeWhat users experienceWhat your tests show
One internal resolverIntermittent stalls; some machines slower than othersDirect queries to that server fail; its twin answers fine
Both internal resolversEverything by name dead, inside and outDirect queries to both fail; raw IP connectivity still fine
The forwarding path (firewall rule, upstream outage)Internal names fine; external names slow or deadInternal lookups green; external lookups SERVFAIL or time out on both resolvers; asking the upstream directly settles who's guilty
Your zone data (a bad or missing record)One internal application unreachable; all else normalEverything resolves except the one name, on every resolver alike
The upstream providerExternal browsing degraded for everyoneDirect queries to the upstream fail from anywhere; your servers innocent

Notice what makes the table work: the layers fail differently. If clients talked to upstreams directly, "internal fine, external broken" would be indistinguishable from a hundred per-client misconfigurations. Because external traffic funnels through one forwarding doorway, that whole class of outage collapses into a single testable question. This is the architecture doing your diagnosis for you — the layout was designed so that symptoms point at layers. The troubleshooting playbook walks these same layers with commands; a clean architecture is what makes its steps come back with crisp answers.


Redundancy done right: two resolvers clients actually use


"We have two DNS servers" is one of those sentences that can mean anything. Redundancy that works has three properties worth spelling out:


  • Both servers are complete. Same zones, same forwarders, same access rules. If dns2 can't do everything dns1 does, you don't have a spare. In that case, you have a decoy that fails over into a different, more confusing outage.
  • Every client knows both. Both addresses in every DHCP scope and every static configuration. A resolver no client is configured to use protects no one, however healthy it is.
  • Both are watched. Clients fail over silently. When dns1 dies, users feel a few seconds of stall and carry on against dns2. Nobody files a ticket, and you are one server from darkness without knowing it. A dead "redundant" resolver discovered months later, during the outage of its twin, is a genre classic.

That last point deserves its own emphasis, because client failover behavior is widely misunderstood. The two resolver entries are not "primary" and "backup" in any strong sense. Operating systems try the first, wait briefly, try the second, and may keep preferring whichever responded recently. In practice both servers see real traffic and both must be genuinely healthy. List order tunes the timeout tax. It does not park one server in reserve. So monitor each by direct query, per the DNS health monitoring guide. Treat "one of the pair is down" with the urgency of "half my redundancy is gone" — because it is.


Redundancy also has a calendar dimension. Your resolvers are servers; servers get patched and rebooted, and during a reboot the pair is a solo act. Two habits keep that safe. Never patch both resolvers in the same window. Check — before starting the second — that the first actually came back and is answering queries, not merely powered on. The grim classic is patching dns1, assuming it recovered, and moving on to dns2. Then you discover mid-reboot that dns1's DNS service never started. That is a self-inflicted total outage assembled from two routine maintenance tasks.


Tip: prove your redundancy on your schedule, not the outage's. In a maintenance window, pause the DNS service on one resolver and watch: do clients carry on with only a brief stall? Does your monitoring name the right server within a couple of minutes? A ten-minute rehearsal answers both questions while the stakes are zero.


The classic architecture mistakes


Every one of these is common. Every one is fixable in an afternoon. And every one makes failures quieter and weirder — the opposite of what you want:


MistakeWhy it hurtsThe fix
A single resolverOne box is now a building-wide off switch; every reboot is an outageStand up a second complete resolver and put it in DHCP everywhere
Clients pointed at public resolversPublic servers can't see internal zones — logons, shares, and internal apps break in baffling ways for exactly those machinesClients use internal resolvers only; the forwarder layer is where public servers belong
Mixing internal and public on one adapter ("public as backup")The client sometimes asks the public server internal questions and gets NXDOMAIN — the textbook intermittent, unreproducible failureBoth entries internal, always; "backup" is the second internal resolver's job
Forwarding loops (A forwards to B, B back to A, often via a firewall's DNS proxy)Queries circle until something gives up; symptoms are random latency and SERVFAILs that vanish under light loadDraw the forwarding graph end to end; arrows must flow strictly upward, no cycles
Stale resolver IPs in DHCP scopes or static configsMachines quietly point at a server that was decommissioned; they limp on the surviving entry until it hiccups, then fail hardAudit every scope and every static config whenever a resolver changes address; better, never reuse resolver IPs for anything else
Hosts-file fixes scattered across machinesOverrides outlive the emergencies that justified them, and those machines ignore your zone edits forever afterTreat hosts entries as temporary by policy; hunt them down when behavior differs per machine
The resolver's own adapter pointing at outside DNSThe server is also a client; if its own adapter bypasses the internal system, directory replication and its own tooling misbehave in slow, strange waysPoint each DNS server's adapter at its partner and itself — never at public resolvers

The second and third rows are worth internalizing as one lesson, because they share a root: resolver choice belongs to the architecture, not to individual machines. The moment someone "fixes" a slow afternoon by pointing their PC at a public resolver, that machine leaves your split-horizon world. Internal names now intermittently fail on it. No server-side investigation will ever explain why, because the cause lives in one adapter's settings. Uniformity isn't bureaucratic tidiness; it is what makes your tests mean anything at all.


Forwarders versus root hints: an honest tradeoff


Your internal resolvers must answer external questions somehow, and there are two respectable ways. Forwarding hands unanswerable questions to a designated upstream. Root hints means your server does full recursion itself, starting from the internet's root servers, trusting no intermediary. Forwarding buys you a shared upstream cache (often faster answers), and any filtering or logging your provider or security stack offers. It also buys one obvious doorway to test during incidents. Its cost: you have adopted a dependency. When the upstream misbehaves, your resolvers fail with it — SERVFAILs raining on people who never chose that provider. Root hints buys independence and one less party to distrust. The cost is doing more work per fresh lookup and losing the shared cache and any upstream filtering.


It genuinely depends, and the deciding factor is usually operational rather than philosophical. Forwarding to a pair of well-run upstreams is simpler to reason about and gives your monitoring an explicit layer to check. That is why the reference layout uses it. Wherever you land, land identically on both resolvers, and write the choice down. A conditional forwarder means "questions about partner.example go to that company's servers; everything else follows the normal path". It is the respectable niche exception for partner and branch zones. Just keep the list short and documented, because each entry is a special case your future self must rediscover.


Designing for loud, localizable failure


Run the same thought experiment against any DNS design decision: when this piece breaks, how will we find out, and how fast can we name the layer? Loud and localizable beats silently absorbed every time. A stall that pages nobody is not resilience. It is a fuse burning down. The habits that keep failures loud:


  • Monitor every layer by direct query — each internal resolver, and the upstream doorway. That way, the failing layer names itself instead of hiding behind client failover.
  • Declare dependencies in monitoring so a dead resolver produces one alert about the resolver, not fifty about everything downstream of it. That is the discipline covered in dependency thinking.
  • Keep one current diagram — the whiteboard sketch from earlier, with real names and IPs, stored where the on-call person will actually look. Ten minutes of drawing converts every future incident's first hour into its first five minutes.
  • Name servers for their jobs. dns1 and dns2 beat inherited pet names; alerts and diagrams should read like sentences.
  • Test from where users sit. A check running on the server proves the service is alive, not that the building can reach it. At least one probe on the client side of the path catches the firewall-shaped failures the server itself never sees.
  • Change one layer at a time, and note the change where the on-call person will see it. Half of "sudden DNS weirdness" follows an unrecorded tweak to forwarders or firewall rules.

An architecture health checklist


Score your own network — each "no" is a future incident with a scheduling preference for long weekends:


  • 1. Two complete internal resolvers, identical zones and forwarders?
  • 2. Every DHCP scope and static config lists both — and nothing else?
  • 3. No client anywhere pointed at a public resolver, even as "backup"?
  • 4. Forwarding graph drawn end to end, arrows strictly upward, no loops?
  • 5. Each resolver and the upstream doorway monitored by direct query?
  • 6. Failover rehearsed in a maintenance window at least once?
  • 7. One current diagram the on-call person can find at 2 a.m.?

Seven yeses means your next DNS incident will be short, specific, and almost dull — which is the entire ambition of infrastructure design.


Where to go next


Architecture and monitoring are two halves of one promise: that when name resolution breaks, you find out first and know where to look. This article gave you the debuggable layout. The guide Monitoring DNS Health wires the per-layer checks onto it. The troubleshooting playbook is the command-line companion for the day a layer fails anyway. The rest of the series lives at It's Always DNS: Name Resolution Health.


Put this into practice with SysPeep Monitor

Two resolvers only protect you if you notice when one dies — and clients fail over too politely to tell you. SysPeep Monitor auto-discovers your servers and watches each resolver's host independently over WMI, SNMP and SSH. Its dependency rules turn a dead forwarder into one clear alert instead of fifty downstream ones. It runs from a single Windows machine, with lightweight remote probes for branch sites.

Download Free TrialLearn About SysPeep