The message arrives about twenty minutes after every DNS migration. "It's not working on my end." You've already watched three propagation checker sites turn green. You've reloaded your browser twice. Everything looks correct from your machine.
What you haven't done is prove it's correct from anyone else's.
DNS changes fail in ways that are genuinely hard to diagnose without a system. I've seen a stale DMARC record quietly break deliverability for three weeks before anyone traced it back to a migration. I've watched a fresh A record propagate to Google's resolvers while Cloudflare was still caching the old IP, because the TTL math wasn't done before the change. I've spent two hours on a "broken email" ticket that turned out to be a registrar's NS propagation taking 36 hours, not 48 minutes.
The three checks below take roughly 15 minutes total. I run them before closing any DNS ticket. They've saved me from that follow-up message more times than I want to count.
Step zero: sort the TTL before you touch anything
TTL (Time to Live) is the number of seconds DNS resolvers are allowed to cache a record before they fetch a fresh value. If you walk into a migration with TTL still at the registrar's default, often 86400 seconds (24 hours), you can update the record and watch it resolve correctly on your laptop while half the world serves the old value for the rest of the day.
The fix is simple but requires planning ahead. A day or two before any significant DNS change, reduce the TTL on the affected records to 300 seconds (5 minutes). Some practitioners drop it to 60 seconds for the most sensitive changes, though that increases DNS lookup traffic slightly. The point is to shrink the stale cache window so the cutover lands fast.
The check I run before closing the pre-change task:
dig example.com A +noall +answer
Read the third column of the output. That's the TTL currently being advertised. If it's still at 86400, the update you made in the registrar panel hasn't propagated yet, or you made it in the wrong record. Do not proceed until it matches what you set.
After the main change is confirmed, bring the TTL back to something reasonable, typically 3600 seconds. Leaving it at 60 or 300 forever is a small but real cost: more DNS lookup traffic on every resolve, and faster unintended propagation if someone fat-fingers a record later.
Check 1: query three resolvers, not your browser
Your browser caches DNS. Your OS caches DNS. Your office router and your ISP both cache DNS. When you open a tab and the site loads, that is often not telling you what an external user sees. It may be telling you what your machine cached 20 minutes ago.
The only way to verify propagation is to query resolvers directly. I use three:
- Google:
dig @8.8.8.8 example.com A +short - Cloudflare:
dig @1.1.1.1 example.com A +short - OpenDNS:
dig @208.67.222.222 example.com A +short
If all three return the new IP, propagation is functionally complete for the majority of users. If one is still serving the old value, I note which resolver and check again after one more TTL cycle. If only one resolver is updated after several cycles, the issue is usually upstream: the nameserver itself wasn't updated, not just a cache problem.
For MX records (email routing), substitute MX for A in the query. For TXT records (SPF, DKIM, DMARC), use TXT. SPF in particular is case-sensitive and easy to fat-finger. I always read the returned TXT value character by character against what I intended to set.
On Windows without dig, the equivalent is nslookup -type=A example.com 8.8.8.8. DNSChecker.org works well in a browser when you need to check propagation across many geographic regions at once and want a visual confirmation. I use it as a second pass, not a first.
Check 2: test the actual service, not just the record
A DNS record resolving correctly does not mean the service is working. This is the check most people skip, and it is the one that produces the "it was working when you closed it" follow-up two days later.
What to test depends on the record type:
A/CNAME changes (web hosting, CDN, app): Load the site over HTTPS from an incognito window to avoid browser cache. Confirm the SSL certificate matches the domain. A certificate mismatch almost always means the IP is correct but the new host hasn't provisioned the cert yet. That's a different problem from DNS, but you want to catch it now.
MX changes (email routing): Send a real test email from an external address to the domain and confirm it delivers to the new mail server. A bad MX priority value, a firewall rule on the new mail host, or an unconfigured mail server on the other end can all look exactly like "DNS propagated, email is broken." The record being correct and the service working are not the same thing.
TXT changes (SPF, DKIM, DMARC): Run a full email authentication check. Mail Tester and MXToolbox both send a probe and report whether the authentication chain passes end to end. The dig query confirms the record exists. The tool confirms the values are syntactically valid and correctly aligned to the domain. You need both.
A correct record and a working service are not the same test. Run both.
Check 3: document before you close the ticket
This one is not technical. It's the discipline that makes the other two checks worth doing.
Before I close any DNS ticket, I add two lines: what I queried or tested, from where, and what result I got, plus the timestamp. It takes 90 seconds. Here's what it looks like in practice:
Verified: A record at 8.8.8.8, 1.1.1.1, and 208.67.222.222 all return 203.0.113.42 (new IP). Sent test email from Gmail at 14:38 UTC, delivered to new host inbox within 2 minutes. HTTPS loads cleanly, cert valid for example.com.
When something breaks 48 hours later and IT gets pulled in, the first question is always "was this working immediately after the change?" Without a note, you're guessing. With the note, you can close that question in ten seconds and focus on what actually changed between then and now.
The documentation habit also forces a useful rethink before closing. If I can't write down what I tested and what result confirmed success, I haven't verified anything, and I know to keep the ticket open.
One more thing worth writing in the ticket before the change, not after: the old record value. If I need to roll back because something breaks downstream, the previous record is right there. I don't have to dig through the registrar's audit log or search my own emails hoping I pasted it somewhere.
Why 15 minutes now beats two hours later
None of this is complicated. The TTL check is one dig command. The resolver queries take three more. The service test takes five minutes at most if you know what you're testing. The documentation is two sentences.
What makes it worth doing is the asymmetry. The "it's not working" follow-up doesn't just cost 15 minutes. It costs a conversation where you have to reconstruct what you changed and when without contemporaneous notes, often in front of someone who's already frustrated. It costs the time to diagnose whether the issue is DNS cache, the service itself, or something unrelated that happened to break at the same time. It costs credibility when the answer is "I thought it looked right."
The propagation checker going green is a sign, not a proof. The proof is a resolver query you ran yourself, a service test you performed, and a note in the ticket that says you did both.
Sources
- DNSChecker.org (multi-region propagation tool)
- MXToolbox Super Tool (MX, SPF, DKIM, DMARC checks)
- Mail Tester (live email authentication verification)
- IANA TTL guidance: DNS Parameters (iana.org)
Questions about domain management or IT ops? Get in touch.