Networking & Protocols
TTL, caching, and DNS propagation
You updated a DNS record and your co-worker can see the change. You cannot. An hour later you finally see it. Your manager calls this “DNS propagation” and says to wait 24–48 hours. That framing is technically wrong and operationally expensive. Understanding what TTL actually is — permission, not a command — changes how you manage DNS records in production.
What TTL means
Every DNS record carries a TTL (Time To Live) — a number in seconds. When a resolver caches an answer, it counts down from TTL to zero. At zero it discards the cached record and re-queries. The authoritative server does not push updates; caches expire and pull the new value on their own schedule.
This has two operational consequences:
- You cannot force a cached value to disappear. Once a TTL is published and cached, you must wait for that TTL to count down everywhere.
- “DNS propagation” is a misleading term. Nothing propagates. All that happens is that distributed caches expire one by one. There is no wave; there is no timeline. A cache that was populated 1 minute before your change will hold the old value for (TTL - 1 minute) longer.
High TTL vs low TTL
| TTL | Benefit | Cost |
|---|---|---|
| High (86400 s = 1 day) | Few queries; fast cache hits; authoritative server handles less load | Stale data lingers up to 1 day after a change |
| Low (60 s) | Stale data clears in 1 minute after a change | More queries; higher load on authoritative; cache cannot serve stale during outage |
- TTL = 60 s
- ~17% cache hits
- TTL = 300 s
- ~50% cache hits
- TTL = 3600 s
- ~90% cache hits
- TTL = 86400 s (1 day)
- ~99% cache hits
- Planned-change SOP
- Lower TTL to 60 s one week before, change, raise back
Planned migration SOP
The standard operational pattern for a planned DNS change:
- One week before: Lower TTL to 60 seconds. Wait for the old high TTL to expire everywhere (max wait = old TTL).
- Change day: Update the record. Bad outcome reachable immediately — max cache age is now 60 s.
- After stabilisation: Raise TTL back to 3600 s or higher.
Skipping step 1 means old caches can serve stale data for up to the old TTL (e.g., 24 hours) after your change.
Negative caching (RFC 2308)
DNS caches do not only store positive answers. They also cache negative responses:
- NXDOMAIN (name does not exist) — cached for
min(SOA.MINIMUM, SOA.TTL), typically 1–3 hours. - NODATA (name exists but no record of that type) — same cache duration.
- SERVFAIL — cached briefly per RFC 9520: 30 seconds to 5 minutes. Short enough to not amplify an outage, long enough to prevent a tight retry loop.
Negative caching is essential for performance: without it, every query for a non-existent subdomain would hit the authoritative server every time. Without SERVFAIL caching the internet’s early typo storms and misconfigured clients could flood authoritative servers into collapse.
What does TTL actually tell downstream resolvers?
You change an A record on your authoritative server. A resolver cached the old value 10 minutes ago with TTL=3600. How long before that resolver serves the new value?
SOA record and zone authority
Every zone has exactly one SOA (Start of Authority) record at the apex. Its fields govern replication and negative caching:
- SERIAL: incremented on every zone change. Secondaries compare their serial to the primary’s; if lower, they pull an update.
- REFRESH: how often secondaries poll without a NOTIFY (typically 1–24 hours).
- RETRY: poll interval when REFRESH fails.
- EXPIRE: how long a secondary serves stale data when the primary is unreachable (often 1 week).
- MINIMUM: negative-cache TTL (RFC 2308). The actual negative TTL is
min(SOA.MINIMUM, SOA.TTL).
Common ops mistake: decrementing SERIAL. The convention is YYYYMMDDNN format (2026051301 = 2026-05-13, change #01). Manual edits that decrement SERIAL break replication silently — secondaries skip the “older” zone.
Order the recommended steps for a planned DNS migration (changing an A record IP):
- 1 Identify current TTL (e.g. 86400 s)
- 2 Lower TTL to 60 s; wait for old TTL to expire everywhere
- 3 Update the A record to the new IP
- 4 Monitor for errors; verify new IP is resolving correctly
- 5 Raise TTL back to 3600 s or higher
Why this works
Stale-while-revalidate (RFC 8767). When an upstream authoritative is unreachable but a cache entry exists past its TTL, a resolver may serve the stale answer for up to 1–3 days (configurable) while attempting a refresh in the background. This dramatically improves availability during authoritative outages at the cost of serving slightly stale data. Unbound supports this with serve-expired yes. The trade-off: if a zone was intentionally removed rather than just unavailable, stale-while-revalidate hides the deletion from users longer than the TTL would suggest.
Browser DNS cache
Browsers maintain their own DNS cache, separate from the OS stub resolver and the upstream recursive resolver. Chrome caches DNS entries for approximately 1 minute regardless of the record’s actual TTL — intentionally short enough to forget potentially malicious answers, long enough to avoid re-resolving every link on a page. Firefox follows a similar policy.
Clearing the OS-level DNS cache (sudo systemd-resolve --flush-caches on Linux, sudo killall -HUP mDNSResponder on macOS) does not clear the browser’s cache. To force a full re-resolution: restart the browser or visit chrome://net-internals/#dns and clear the host cache.
Browsers also pre-warm DNS via <link rel="dns-prefetch" href="//cdn.example.com"> — resolving names before the user clicks a link so the lookup latency is hidden.
- 01Operational impact of high TTL vs low TTL — name one benefit and one cost of each.
- 02You observe dig @1.1.1.1 example.com A returning 80 ms on every query. What does this suggest?
- 03What is negative caching and why is it important?
TTL is a maximum hold time for downstream caches, not a validity guarantee from the authoritative server. DNS has no push mechanism: “propagation” is just distributed caches expiring one by one. To manage a planned change safely, lower the TTL well before the change so the worst-case staleness window is short. Negative responses — NXDOMAIN, NODATA, and SERVFAIL — are also cached, governed by SOA.MINIMUM and RFC 9520 respectively. The SOA record controls zone replication: SERIAL increments signal secondaries to pull updates, and decrementing SERIAL silently breaks replication. Browsers maintain their own DNS cache independent of the OS resolver; clearing the OS cache does not affect the browser’s cache.
appears again in152
- Why GraphQL gets N+1junior
- DataLoader mechanics: tick-boundary batchingmiddle
- Batch function contracts: ordering, shapes, errorsmiddle
- Federation and lookahead: batching beyond DataLoadermiddle
- Query complexity defences: depth, cost, persisted queriesmiddle
- Senior GraphQL API: scheduling contract, tenant isolation, observabilitysenior
- Why idempotency: making retries safejunior
- Server-side state machine: four states of an idempotency keymiddle
- Outbox and inbox: effectively-once across the dual-write boundarymiddle
- Concurrency and cache architecture for idempotency at scalesenior
- Observability, production failures, and global-scale designsenior
- The event loop: one thread, three queuesjunior
- Tasks, microtasks, and scheduler.yield()middle
- Microtask starvation, Long Tasks, and LoAFsenior
- Node.js event loop: phases, nextTick, and loop lagsenior
- React, Vue, and INP observability in productionsenior
- The render pipeline: six stages from bytes to pixelsjunior
- Stage costs and the renderer process modelmiddle
- Invalidation, dirty bits, and containmiddle
- Compositor layers: promotion, overlap, and GPU memorymiddle
- DevTools flame strip and the frame lifecyclemiddle
- Layout thrash: forced synchronous layoutsenior
- BeginMainFrame, compositor-driven animations, and GPU memorysenior
- Production observability: LoAF, INP, and the full attack surfacesenior
- What V8 is and why performance varies 100×junior
- V8''''s four-tier JIT pipeline and profile-guided tieringmiddle
- Hidden classes, transition trees, and memory layoutmiddle
- Inline caches, IC states, and deoptimizationmiddle
- Orinoco GC: parallel scavenger, concurrent marking, and write barriersmiddle
- TurboFan''''s speculative engine and the deopt-loop trapsenior
- V8 in production: isolates, pointer compression, and real failuressenior
- Service worker lifecycle and cache strategiesmiddle
- Service worker edge cases: version skew, durability, and navigation trapssenior
- What the reconciler does: render vs commitjunior
- The fiber object and the double-buffer treemiddle
- Render phase purity and commit phase sub-stepsmiddle
- Reconciliation: diffing heuristics and the key trapmiddle
- Priority lanes, time-slicing, and useTransitionmiddle
- Bailout, memoisation, and tearingsenior
- React Profiler, the Compiler, and production observabilitysenior
- Rendering strategies: SSG, SSR, ISR, streaming, and hydrationjunior
- SSG, SSR, ISR, streaming, and RSC — how each worksmiddle
- Hydration cost: selective, progressive, islands, resumabilitymiddle
- Hydration mismatch: causes, detection, and the determinism rulesenior
- RSC, per-route strategy, and production observabilitysenior
- Core Web Vitals: what LCP, INP, and CLS measurejunior
- CLS: why layout shifts happen and how to stop themmiddle
- Metric tradeoffs, RUM attribution, and the CI+field loopsenior
- The full picture: URL to LCP to INP as a relay racejunior
- Eight layers traced: from the service worker to the second navigationmiddle
- Five canonical breaks: where production reliably diessenior
- The three-track method: reading traces and building a monitored systemsenior
- What is a cache stampede and why it makes things worsejunior
- Lock and single-flight: bounding concurrent rebuildsmiddle
- XFetch: coordination-free probabilistic early expirationmiddle
- Stale-while-revalidate and CDN request coalescingmiddle
- Detecting stampedes and designing TTL for productionmiddle
- Metastable failure, fencing tokens, and production postmortemssenior
- What a relation is: tables, rows, keys, and constraintsjunior
- Constraints, keys, and Postgres data typesmiddle
- Normal forms, denormalization, and why schemas stickmiddle
- JSONB, arrays, and when a side table winsmiddle
- Heap storage, TOAST, and column alignmentsenior
- Schema integrity: deferral, versioning, and production failure modessenior
- Relational vs document, wide-column, graph, and key-valuesenior
- Index-only scans, the Visibility Map, and INCLUDEsenior
- Production failure modes and the index audit playbooksenior
- pg_statistic, ANALYZE, and production observabilitymiddle
- Production failure modes and plan stabilitysenior
- MVCC: why readers and writers never wait for each otherjunior
- Row versions and snapshots: the on-disk mechanicsmiddle
- HOT updates and isolation levels: what you gain and what you paymiddle
- Vacuum and bloat: keeping the storage tax boundedmiddle
- CLOG, XID wraparound, and MultiXact: deep visibility internalssenior
- SSI internals and production autovacuum tuningsenior
- Real-world MVCC failures, deployment patterns, and distributed snapshotssenior
- Connection pools: amortising the cost of a Postgres backendjunior
- PgBouncer session, transaction, and statement modesmiddle
- Pool sizing: the (cores × 2) + spindles formula and the two-layer stackmiddle
- Pool exhaustion and idle-in-transaction: the 3 AM failure modemiddle
- Migrating to transaction mode: rollout playbook and PgBouncer 1.21 prepared statementsmiddle
- The Postgres process model and why raising max_connections degrades throughputsenior
- Pooler landscape 2026, serverless connection storms, and the full failure-mode taxonomysenior
- What a schema migration is and why it replaces ad-hoc DDLjunior
- ADD COLUMN: instant in PG 11+ vs rewrite in older Postgresjunior
- The lock-queue failure mode: why instant DDL can freeze the databasemiddle
- Safe DDL patterns: NOT VALID, CONCURRENTLY, and unsafe-op fixesmiddle
- Expand-contract: zero-downtime for breaking schema changesmiddle
- Advisory locks, migration tools, and deploy coordinationsenior
- Migration failure taxonomy and production disciplinesenior
- Why sharding exists: the single-Postgres ceilingjunior
- Shard-key selection: hash, range, list, and directory strategiesmiddle
- Partitioning vs sharding: same word, two different thingsmiddle
- Co-location and Citus: the invariant that makes sharding usablemiddle
- The hot-shard failure mode: detection, isolation, and durable policymiddle
- Schema-based sharding and multi-tenancy alternativessenior
- Online resharding, 2PC, and the operational cost of shardingsenior
- The seven acts: from CREATE TABLE to Citusjunior
- Acts 1–3 in depth: schema, indexes, and planner statisticsmiddle
- Acts 4–6 in depth: MVCC bloat, connection pooling, and safe migrationsmiddle
- Act 7 in depth: sharding, co-location, and the seven-tier tradeoff cascademiddle
- Observability, anti-patterns, and production triagesenior
- Raft roles, terms, and why majority quorums prevent split brainjunior
- How Raft replicates a log entry and decides it is safe to commitmiddle
- Raft leader election: timeouts, voting rules, and the four safety propertiesmiddle
- Raft in the real world: partitions, slow disks, and client routingmiddle
- Raft extensions: pre-vote, learners, snapshots, and linearizable readssenior
- Raft in production: membership changes, Multi-Raft, and observabilitysenior
- Where data fetching happens — and why it decides LCPjunior
- Fetch waterfalls — diagnosis and the Promise.all curemiddle
- React Server Components and Suspense streamingmiddle
- Client-side cache: TanStack Query, SWR, and stale-while-revalidatemiddle
- LCP, prefetch, and race conditions in interactive fetchingmiddle
- Senior internals: RSC payload, caching layers, and production failure modessenior
- What the three signals are: logs, metrics, and tracesjunior
- Why structured logs exist: the diary vs the spreadsheetjunior
- The production log schema: fields every line must carrymiddle
- PII redaction and log injectionsenior
- OTel Logs Data Model and audit logs as a subsystemsenior
- SLI, SLO, and the error budget: reliability by the numbersjunior
- Error budget policy, latency SLOs, and composite journeysmiddle
- Production SLO failures, self-observability, security, and the big picturesenior
- The incident loop: from pager to postmortem to preventionmiddle
- Cache lines, struct layout, and false sharingmiddle
- SIMD, SoA vs AoS, and memory bandwidthmiddle
- Cache-oblivious algorithms, PGO, and production failuressenior
- GC in production: observability, security, edge cases, and fleet governancesenior
- Batching: amortize fixed cost per operationjunior
- The batching window: size and wait timemiddle
- Batching in Kafka and Postgresmiddle
- io_uring and observability of batchingmiddle
- From Nagle to io_uring: evolution of batchingmiddle
- Backpressure, failure isolation, and batch security in productionsenior
- CI enforcement and RUM: making budgets stickmiddle
- V8 JIT pipeline, HTTP priorities, and bundle securitysenior
- The performance loop: discipline, not a projectjunior
- Classify and fix: matching bottleneck families to remediesmiddle
- Observability stack and CI gates: catching regressions before they shipmiddle
- Incident to enforcement: SLO burn to verified fix in 35 minutesmiddle
- Culture, economics, and org-scale performancesenior
- At-most-once, at-least-once, exactly-once: the three delivery contractsjunior
- The three failure legs — where duplicates and losses actually happenmiddle
- Consumer-side dedup: the cheapest path to exactly-once processingmiddle
- Kafka exactly-once semantics: idempotent producer and transactionsmiddle
- SQS visibility timeout, DLQ, and the outbox patternmiddle
- Exactly-once in production: impossibility proof, hybrid patterns, and real incidentssenior
- What OAuth is and why passwords are not the answerjunior
- Authorization code flow with PKCEmiddle
- ID token validation and JWKS cache managementmiddle
- Refresh token rotation and scope-based least privilegemiddle
- Sender-constrained tokens: DPoP and mTLSsenior
- OAuth in production: audience attacks, observability, and real failuressenior