Networking & Protocols
DNS: what it does and why it exists
You type google.com into your browser. The browser does not know where Google is — it knows names, not numbers. Before it can open a TCP connection or send an HTTP request, it needs the IP address. That lookup is DNS, and it happens silently on every page load.
What DNS does in one sentence
DNS (Domain Name System) translates a human-friendly name like google.com into the numeric IP address (142.250.185.46) the network layer needs to route packets. Without DNS you would need to memorise dozens of IP addresses per service and update them every time a server moved.
The tree of servers
DNS is a global hierarchy. Three tiers handle every query:
- Root servers — 13 named servers (A–M), each replicated to hundreds of locations via anycast. They do not store domain records; they know which TLD server to ask next.
- TLD servers — one set per top-level domain (
.com,.org,.uk,.io, etc.). They know which authoritative server owns a given domain. - Authoritative nameservers — own the zone files for individual domains (
google.com,example.co.uk). They return the final answer.
- Root servers (named)
- 13 (A–M)
- Root instances (anycast)
- 1 000+
- TLD servers
- one set per TLD (.com, .org, …)
- Authoritative servers
- one per registered domain
- DNS wire protocol
- UDP/TCP port 53
- Typical cold lookup latency
- 30–100 ms
- Typical warm lookup (cached)
- under 1 ms
The phonebook metaphor
Imagine you want to call a restaurant you know only by name. You call directory assistance (the recursive resolver). The operator does not know the number but knows how to find it. She calls a central office (root server), gets redirected to a regional directory (TLD server), and from there to the restaurant’s front desk (authoritative server). The front desk gives the number; the operator relays it and writes it down. The next caller asking the same question gets the cached answer instantly.
The resolution dialogue
A user’s browser sends a query to its configured recursive resolver. If the resolver has no cached answer, it walks the tree:
- Browser asks resolver: “What is the IP for
example.com?” - Resolver asks root: “Who handles
.com?” Root: “Ask the.comTLD server.” - Resolver asks
.comTLD: “Who handlesexample.com?” TLD: “Ask this authoritative server.” - Resolver asks authoritative: “IP for
example.com?” Auth: “203.0.113.10, TTL=300.” - Resolver returns IP to browser, caches the answer for 300 seconds.
On the next query within those 300 seconds the resolver skips steps 2–4 and answers from cache.
Order a cold lookup of example.com:
- 1 Browser asks recursive resolver for example.com
- 2 Resolver asks root: who handles .com?
- 3 Root replies with referral to .com TLD
- 4 Resolver asks .com TLD: who handles example.com?
- 5 TLD replies with referral to authoritative server
- 6 Resolver asks authoritative: IP of example.com?
- 7 Authoritative replies with the A record
- 8 Resolver caches and returns IP to browser
One scenario end to end
You click a link. Underneath, the browser does DNS first — to learn the IP. Once it has the IP it opens a TCP connection to that address, then adds TLS on top, and finally sends the HTTP request. Every new browser tab repeats the DNS step unless the answer is still cached. DNS is always the first step of an internet connection.
What does DNS actually return for a standard domain lookup?
Why does caching exist at every layer of DNS?
DNS is like a global _______ that translates human-readable names into IP addresses.
Why this works
Why 13 root servers, not one. DNS was designed in 1987 when the internet was tiny. The 13-server limit came from the 512-byte UDP limit — you can fit exactly 13 IPv4 addresses in one DNS response. Today each “root server” is really hundreds of machines spread across every continent via anycast: your root query reaches the nearest instance, typically under 5 ms, without you knowing which physical machine answered.
- 01Why do almost all DNS lookups feel instant after the first one?
- 02What is the role of the recursive resolver, and how does it differ from an authoritative server?
- 03Name the three tiers of the DNS hierarchy in order.
DNS is a globally distributed hierarchy that maps human-readable names to IP addresses. When a browser needs to connect to a new domain, it asks a recursive resolver. The resolver walks from root servers, to TLD servers, to the authoritative nameserver for that domain, collecting referrals at each step. The final answer — an A record with the IPv4 address and a TTL — is returned to the browser and cached at every layer. TTL governs how long caches hold the answer before re-querying. A warm cache makes DNS nearly instant; a cold walk costs 30–100 ms across three round-trips. DNS happens before TCP, before TLS, and before HTTP — it is the first step of every internet connection.
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