Preventing DNS Split-Brain in Hybrid Azure/AD
A technical guide to eliminating DNS split-brain in hybrid Azure/AD environments using NRPT, GPO policy and Azure Private DNS Resolver architecture.

Advertising disclosure: this article includes partner links. KBY may earn a commission if you sign up or buy through one, at no extra cost to you. How we make money.
A hybrid identity environment running Active Directory Domain Services alongside Azure Private DNS zones will inevitably encounter DNS split-brain the moment a device roams between the corporate LAN, a site-to-site VPN, and the public internet. The symptom looks simple: the same FQDN resolves to two different IP addresses depending on which resolver answers the query, one from an internal AD-integrated zone, one from a public authoritative zone or an Azure Private DNS zone linked to a different VNet. The result is broken Kerberos SPN validation, TLS SAN mismatches on internal load balancers, and intermittent connectivity that is almost impossible to reproduce in a lab because it is entirely dependent on network path. You can stop DNS split-brain by letting the client choose the resolver itself through the Windows Name Resolution Policy Table (NRPT), rather than relying on brittle conditional forwarders or hosts-file hacks.
#Why one name resolves to two addresses
In a typical hybrid estate, an organisation owns a namespace such as corp.example.com. On-premises AD DS hosts an authoritative, AD-integrated zone for that namespace. Azure Private DNS then hosts a linked zone for the same or an overlapping namespace to support Private Endpoints and Private Link resource resolution inside a VNet. When a domain-joined laptop is on the corporate network, it queries the on-prem DNS server and receives the correct internal record. When that same laptop connects over a split-tunnel VPN or via Always On VPN with force-tunnelling disabled, the client’s default adapter may send the query to a public resolver (ISP DNS, DoH endpoint, or public DNS-over-HTTPS) instead of the internal DNS server, returning either an NXDOMAIN or a public-facing IP that bypasses the private endpoint entirely.
That is DNS split-brain at its plainest: two authoritative answers, picked by where the query came from rather than by a stale record. Standard remediation, adding conditional forwarders on every resolver in the path, does not scale once you introduce Azure Private DNS Resolver, ExpressRoute private peering, and multiple VNets with independent DNS configurations. The client, not the server infrastructure, needs to make the routing decision before the query ever leaves the stack.
#How NRPT picks the DNS server before the query leaves
The NRPT is part of the Windows DNS Client service (Dnscache): when a queried name matches an NRPT namespace, the client sends the query to the DNS servers named in that rule instead of the DNS servers configured on the active network adapter. Originally shipped for DirectAccess to route corporate namespace queries through the IPsec tunnel, NRPT is now the correct mechanism for enforcing deterministic resolution in any hybrid Azure/Windows topology, VPN or otherwise.
Each NRPT rule has three parts:
- Namespace match: an FQDN, a domain suffix (with or without wildcard), or a subnet (for reverse lookups).
- DNS server list: the specific resolver(s) authoritative for that namespace, e.g. an Azure Private DNS Resolver inbound endpoint IP.
- Security flags: optional DNSSEC validation requirement or IPsec enforcement.
#Rule Precedence and Overlapping Namespaces
When NRPT rules overlap, the more specific rule is expected to take precedence over the more general one: a rule for a child namespace wins over a rule for its parent, so a query for a host in azure.corp.example.com follows that rule rather than the broader .corp.example.com rule. Still confirm it on your own build; on a test device, check Get-DnsClientNrptPolicy and run Resolve-DnsName for a name under each namespace to confirm which server answers. With that confirmed, you carve out the sub-namespace hosted in an Azure Private DNS zone into its own NRPT rule pointing at the Azure Private DNS Resolver, while the broader corporate suffix continues to route to on-prem domain controllers. Anything outside the matched namespaces falls through to the adapter’s standard DNS configuration, meaning NRPT is additive and non-destructive to normal internet resolution.

#Map the namespaces, then push the rules
#Step 1: Audit the Overlapping Namespace
Before writing a single rule, enumerate every zone that currently answers for your corporate namespace: the AD-integrated zone, any Azure Private DNS zones linked to VNets, and public zones in Azure DNS or a third-party registrar. Use Resolve-DnsName against each authoritative server directly to map which records diverge. Any FQDN returning different A/AAAA records depending on the queried server is a candidate for an explicit NRPT rule.
#Step 2: Define Authoritative Boundaries
Assign a single authoritative resolver per sub-namespace. Do not attempt to load-balance a namespace across two different authoritative sources, that reintroduces the split-brain condition at the NRPT layer itself. If azure.corp.example.com is authoritative only in Azure Private DNS, every client, regardless of network path, must be forced to query the Azure Private DNS Resolver’s inbound endpoint for that suffix.
#Step 3: Push Rules via Group Policy
NRPT rules are distributed via the Name Resolution Policy GPO node (Computer Configuration\Policies\Windows Settings\Name Resolution Policy), which writes to the registry under HKLM\SOFTWARE\Policies\Microsoft\Windows NT\DNSClient\DnsPolicyConfig. For fleets already managed via Intune or hybrid MDM, the same policy can be delivered as a custom OMA-URI, but GPO remains the more auditable path for domain-joined estates and is what we will use here. For broader context on how these resolution boundaries fit into wider connectivity design, see our overview of architectural patterns for hybrid cloud infrastructure.
#Prototype on one workstation, then build the GPO and resolver
The fastest way to prototype and validate rules before committing them to a GPO is directly on a test workstation using the DnsClientNrptRule cmdlets.
1# Send the Azure-hosted sub-namespace to the Azure Private DNS Resolver
2# inbound endpoint (10.20.0.4, the static IP the provisioning script below assigns),
3# overriding whatever the active adapter would otherwise use.
4Add-DnsClientNrptRule -Namespace ".azure.corp.example.com" `
5 -NameServers "10.20.0.4" `
6 -Comment "Authoritative Azure Private DNS Resolver - azure.corp zone"
7
8# Force the broader corporate suffix to on-prem domain controllers.
9# A local NRPT rule applies on every network, on the corporate LAN and off it.
10Add-DnsClientNrptRule -Namespace ".corp.example.com" `
11 -NameServers "192.168.10.10","192.168.10.11" `
12 -Comment "Authoritative AD-integrated zone"
13
14# List the local rules you just added, then the policy the client actually applies
15Get-DnsClientNrptRule | Format-Table Namespace, NameServers -AutoSize
16Get-DnsClientNrptPolicy | Format-Table Namespace, NameServers -AutoSizeAdd-DnsClientNrptRule without -GpoName writes a local rule, stored separately from GPO-delivered rules, so prototype on a workstation that receives no NRPT rules from Group Policy and compare both outputs. When testing is finished, list the local rules first with Get-DnsClientNrptRule | Format-Table Name, Namespace, Comment and check that only the two prototype rules match. Remove each one by its Name value (a GUID), first as a dry run with Remove-DnsClientNrptRule -Name "<rule name>" -WhatIf, then again without -WhatIf and without -Force, and confirm with Get-DnsClientNrptRule that none remain, so they cannot mask what the GPO delivers during the pilot. Once validated, export the same logic into a GPO for fleet-wide enforcement. The underlying policy is stored as a set of registry multi-string values, but administrators should always author it through the GPMC Name Resolution Policy Table editor rather than hand-editing the registry, since the client parses a specific delimited format that is not officially documented for manual construction. For automation pipelines, write the rule into the GPO with Add-DnsClientNrptRule -GpoName, which produces the format the client expects, rather than building registry values with Set-GPRegistryValue:

1# Create the GPO unlinked, write the rule into it, then link it to a pilot OU only
2Import-Module GroupPolicy
3$GpoName = "NRPT-Hybrid-Split-Brain-Fix"
4New-GPO -Name $GpoName
5
6Add-DnsClientNrptRule -GpoName $GpoName -Server "dc01.corp.example.com" `
7 -Namespace ".azure.corp.example.com" `
8 -NameServers "10.20.0.4" `
9 -Comment "Authoritative Azure Private DNS Resolver - azure.corp zone"
10
11# Pilot: link to a small OU, run gpupdate /force on the pilot devices (or wait for the
12# background refresh), then check Get-DnsClientNrptPolicy and Resolve-DnsName there
13$Pilot = "OU=NRPT-Pilot,OU=Workstations,DC=corp,DC=example,DC=com"
14New-GPLink -Name $GpoName -Target $Pilot
15
16# Link to OU=Workstations only after the pilot is signed off.
17# Rollback: Remove-GPLink -Name $GpoName -Target $Pilot, gpupdate /force on the
18# pilot devices, then confirm with Get-DnsClientNrptPolicy that the rule is gone.
19# If the design is abandoned, Remove-GPO -Name $GpoName deletes the GPO and its rule.On the Azure side, the resolver endpoint that NRPT clients target must be provisioned with an inbound endpoint on a delegated subnet. Microsoft documents that the inbound endpoint needs its own subnet, between /28 and /24, delegated to Microsoft.Network/dnsResolvers and used for nothing else, so delegate it before creating the endpoint. This is covered in the official Azure DNS Private Resolver reference architecture. A minimal provisioning script follows, using the dns-resolver Azure CLI extension. The az dns-resolver create reference in Microsoft’s Azure CLI documentation lists --id as a required parameter in its Virtual Network Arguments group: it takes the resource ID of the VNet the resolver attaches to, not an ID for the resolver itself. The inbound endpoint gets one static IP configuration, 10.20.0.4, the only resolver address the NRPT rules above list.
1# Delegate the dedicated inbound subnet to the resolver service first
2az network vnet subnet update \
3 --resource-group "rg-network-core" \
4 --vnet-name "vnet-hub" \
5 --name "snet-dns-in" \
6 --delegations "Microsoft.Network/dnsResolvers"
7
8# Resource ID of the hub VNet the resolver attaches to
9VNET_ID="/subscriptions/xxxx/resourceGroups/rg-network-core/providers/Microsoft.Network/virtualNetworks/vnet-hub"
10
11az dns-resolver create \
12 --name "pdr-corp-hybrid" \
13 --resource-group "rg-network-core" \
14 --location "uksouth" \
15 --id "$VNET_ID"
16
17# One static IP configuration, 10.20.0.4 (a free address in snet-dns-in), matching the NRPT rules.
18# Shorthand syntax as in the az dns-resolver inbound-endpoint create reference example,
19# single-quoted so bash passes the brackets, braces and commas through unchanged.
20az dns-resolver inbound-endpoint create \
21 --dns-resolver-name "pdr-corp-hybrid" \
22 --resource-group "rg-network-core" \
23 --location "uksouth" \
24 --name "inbound-ep-01" \
25 --ip-configurations '[{private-ip-address:"10.20.0.4",private-ip-allocation-method:"Static",id:"/subscriptions/xxxx/resourceGroups/rg-network-core/providers/Microsoft.Network/virtualNetworks/vnet-hub/subnets/snet-dns-in"}]'The resolver answers from an Azure Private DNS zone only if that zone is linked to the resolver’s VNet, so link every zone your NRPT rules depend on. For Azure PaaS Private Endpoints, clients query the public name (for example myserver.database.windows.net), which is answered with a CNAME into the privatelink zone, so the NRPT rule has to match the public service suffix. That sends every name under the suffix through the resolver, including services that have no private endpoint.
#Old rules that keep DNS split-brain alive
The single most common cause of NRPT deployments failing to actually resolve DNS split-brain is rule shadowing, where an administrator adds a new, more specific namespace rule but forgets that an existing DirectAccess or legacy Always On VPN policy already claims an overlapping suffix with different name servers. A legacy rule for a narrower suffix, or a second rule for the same suffix delivered by another GPO, can send queries to servers you did not intend; the symptom presents as “the fix works on some machines but not others”. Before linking a new NRPT GPO, list every GPO that delivers NRPT rules to the target OUs, run Get-DnsClientNrptPolicy on a device in each to find namespaces that overlap with the new rule, and remove or align the old rules. Always audit the full effective NRPT table with Get-DnsClientNrptPolicy after every GPO change, on a genuinely representative device, not just the domain controller.
#Where split-brain still gets through
NRPT does not close every gap. These problems come up again and again in production hybrid estates:
- Group Policy propagation lag. NRPT changes require a background
gpupdatecycle (default 90–120 minutes) or an explicitgpupdate /force. During the propagation window, a subset of the fleet remains in split-brain, which can be mistaken for a failed fix rather than expected eventual consistency. - IPv6/IPv4 rule asymmetry. Azure DNS Private Resolver can’t use IPv6-enabled subnets, so its inbound endpoint has only an IPv4 address. A client on an IPv6-only network cannot reach a rule’s IPv4 name servers, so confirm every listed server is reachable from each network the client uses.
- DNS-over-HTTPS bypass. If a browser or the OS-level DoH policy is configured independently of NRPT (e.g. Chrome’s built-in secure DNS), queries can bypass the NRPT pipeline entirely, reintroducing split-brain at the application layer even though the OS resolver is correctly configured. To keep NRPT authoritative, control browser secure DNS through policy as well, for example the documented
DnsOverHttpsModepolicy in Chrome and Edge, and manage the operating system’s DoH behaviour with the Windows Group Policy setting Configure DNS over HTTPS (DoH) name resolution under Computer Configuration\Administrative Templates\Network\DNS Client. - Legacy DirectAccess coexistence. Estates transitioning from DirectAccess to Always On VPN frequently retain orphaned DirectAccess NRPT GPOs. Their rules still apply alongside the new ones, so an overlapping DirectAccess namespace can keep sending queries to the old servers until that GPO is unlinked.
- Split-tunnel VPN egress. Even with correct NRPT rules, if the VPN adapter’s metric is lower priority than a Wi-Fi adapter also carrying a default route, queries for names outside the NRPT namespaces can go to the Wi-Fi adapter’s DNS servers rather than the VPN’s. Set the interface metrics correctly before you rely on NRPT.
#What NRPT costs you, and what it buys
Fixing DNS split-brain with NRPT has costs as well as benefits when set against alternatives such as conditional forwarding or full DNS-over-VPN tunnelling:
- Management overhead vs. determinism: NRPT requires per-namespace GPO maintenance and is more labour-intensive to audit than a single conditional forwarder, but it guarantees deterministic client-side routing regardless of which resolver would otherwise have answered.
- Multi-forest complexity: In multi-forest or multi-tenant AD environments, NRPT rules must be scoped per-OU with WMI filters to avoid cross-forest namespace bleed; this adds GPO processing overhead on large estates (>5,000 endpoints) that should be benchmarked before rollout.
- DNSSEC enforcement: NRPT rules can mandate DNSSEC validation per namespace, which conditional forwarders on standard DNS servers cannot enforce at the client. This closes a spoofing vector for the internal namespace but requires the authoritative zone to actually be signed.
- Resolver consolidation: Routing Private Link namespaces exclusively through the Azure Private DNS Resolver limits the damage a misconfigured on-prem forwarder can do, but creates a hard dependency on the resolver’s inbound endpoint availability. Plan for that dependency, and if you add resolver capacity, such as a second inbound endpoint, add its address to the NRPT rules only once it has been provisioned, so that every name server a rule lists actually exists.
- Client-side attack surface: Because NRPT lives in the client registry, anyone with local administrator rights on an endpoint can add or alter rules; remove standing local administrator rights, and monitor the
DnsPolicyConfigpolicy key and the effective table (Get-DnsClientNrptPolicy) for rules your GPOs did not deliver.
#Related reading
Configuring Hybrid DNS Conditional Forwarders for Azure and AD
Resolving Hybrid DNS Failures for Entra ID Hybrid-Joined Devices
Palo Alto HA Pair Split Brain: Diagnose and Recover Safely
DNS Resilience Defaults Silently Override Expected Safeguards
Evidence trail
Sources and verification
Primary documentation and external technical references used in this article.
About this page
Credited to
Dates
Published
Last updated
Corrections
Discover more
Graduate Learning
Ops Playbook
Was this useful?
Reports go to the site owner and are used to correct pages. Corrections are listed at /corrections.
Engineering insights, direct to you.
Receive the latest Systems Engineering tutorials, production guides, Engineering Labs and operational best practices.
Comments
Add a thoughtful note on Preventing DNS Split-Brain in Hybrid Azure/AD. Comments are checked for spam and held for moderation before appearing.