markdown formatted blog content

The Hidden Cost of DNS Query Duplication: Why Your Recursive Resolver Might Be Over-Querying

If you've ever studied economics, you've likely encountered the concept of the "tragedy of the commons" — a situation where shared resources get over-consumed because individual users bear no direct cost for their usage. Well, here's a tech twist on that classic scenario that might make you see your DNS resolver in a whole new light.

The Free Lunch Mentality

In the DNS ecosystem, queries are essentially free for recursive resolvers. They're the DNS equivalent of grabbing unlimited napkins at a fast-food restaurant — why not take a dozen when they're just sitting there?

But here's where it gets interesting from a NameOcean perspective: while your recursive resolver is happily firing off duplicate queries without a second thought, someone else is footing the bill. The authoritative nameserver has to process every single one of those queries, generating responses and consuming bandwidth — all without the recursive resolver paying any penalty for its enthusiasm.

So what's driving this over-querying behaviour? The thinking goes something like this: if a UDP packet gets lost in transit, why wait around for a timeout when you can just fire off another query immediately? If both queries succeed, you just ignore the second response. If the first one failed, the second one might succeed — and you saved yourself precious milliseconds.

It's a clever strategy, really. Just not a particularly considerate one.

What the Numbers Tell Us

Here's where things get eye-opening. Analysis of APNIC Labs measurement data from June 2026 reveals some pretty stark regional differences in query duplication rates:

| Region | Query Duplication Rate | |--------|------------------------| | Indian Subcontinent | 61% | | China/Hong Kong | 47% | | Global Average | 38% | | North America | 28% | | Europe | 27% |

These numbers are striking. On average, nearly four out of every ten queries is a duplicate. In the Indian Subcontinent, that jumps to more than six out of ten. And in some cases, the duplication is even more extreme — certain queries get repeated 5, 10, even 20 times before the resolver gives up.

Why Should You Care?

At NameOcean, we host DNS for thousands of domains, so this isn't just an academic concern. When you're running authoritative nameservers at scale, query duplication becomes a real operational challenge.

Think about it: every duplicate query represents wasted compute resources, unnecessary network traffic, and increased latency for everyone. If you're a startup building applications that depend on fast, reliable DNS resolution, this inefficiency directly impacts your users' experience.

For developers working on high-performance systems, understanding DNS behaviour is crucial. If your application is making repeated DNS lookups for the same domain, you're not just burning through your own resources — you might be contributing to the load on the authoritative servers you're querying.

The Path Forward

The DNS community has been aware of these issues for years, and there are ongoing efforts to improve the situation. DNS-over-HTTPS (DoH) and DNS-over-TLS (DoT) are bringing encryption to DNS, which can help with some efficiency issues. EDNS Client Subnet (ECS) extensions help resolvers cache responses more effectively.

But the fundamental "queries are free" problem remains largely unaddressed. Until there's a mechanism to make recursive resolvers bear some cost for their query behaviour, we'll continue to see these inflated duplication rates.

For now, the best approach is awareness. If you're building systems that depend heavily on DNS lookups, consider implementing intelligent caching strategies. Use tools like dig to investigate what's actually happening with your DNS queries. And if you're a NameOcean customer, rest assured that our infrastructure is built to handle these real-world patterns efficiently.

The tragedy of the commons continues — but at least now you understand it better.