Networking & Protocols
Anycast and GeoDNS: routing to the nearest edge
You want every user — whether in London, Tokyo, or São Paulo — to hit the nearest CDN server automatically, without manually configuring routes or maintaining separate URLs per region. Two mechanisms solve this: Anycast and GeoDNS. They work differently and are often used together.
Anycast IP routing
With Anycast, the CDN operator announces the same IP address (e.g. 93.184.216.1) from multiple geographic locations simultaneously via BGP. BGP routing selects the “nearest” edge location as measured by AS path length or hop count. When a user makes a request, their local router sends it to the closest POP advertising that IP — no special DNS needed, just standard BGP routing.
Upside: works automatically; any network-level change (POP added, withdrawn) takes effect within BGP convergence time (seconds to minutes). Downside: BGP “nearest” is hop-count nearest, not latency-nearest. Two cities equidistant by hops can differ by 50 ms of real latency.
GeoDNS
With GeoDNS, the CDN’s authoritative nameserver returns different A records based on the geographic location of the resolving nameserver. A query from a London resolver returns a London edge IP; a Tokyo resolver gets Tokyo. This gives the operator explicit control over routing — you can steer different regions to different POPs manually.
The resolver vs. the user. GeoDNS sees the resolver’s IP, not the browser’s. A user in Toronto using Google’s 8.8.8.8 resolver gets the IP for whichever region Google’s DNS server appears to come from — often Mountain View, CA — which may route them to a US POP instead of a Toronto one. That’s suboptimal.
EDNS Client Subnet (ECS) partially fixes this: resolvers that opt in send the user’s /24 subnet prefix alongside the DNS query, letting the authoritative server return a location-aware IP. Cost: the user’s subnet prefix travels up the DNS delegation chain, reducing privacy. Apple’s iCloud Private Relay and Cloudflare’s 1.1.1.1 disable ECS for this reason, accepting slightly suboptimal routing.
- Anycast selection basis
- BGP AS path length (hop count)
- GeoDNS selection basis
- Resolver IP geolocation
- Anycast BGP convergence on POP change
- Seconds to minutes
- GeoDNS TTL (typical)
- 30–60 s for fast steering
- EDNS Client Subnet granularity
- /24 prefix (user subnet)
- Cloudflare smart routing (Argo) p95 saving
- 30–50% on intercontinental paths
How CDNs combine both
Most large CDNs use Anycast at the IP layer and GeoDNS on top to combine their strengths. Anycast handles DDoS absorption well — volumetric attacks are spread across every POP advertising the IP. GeoDNS provides explicit failover: withdraw a POP from DNS when unhealthy, so new connections stop arriving within one DNS TTL.
Why this works
Why Anycast alone is not enough for CDNs. Anycast routes by BGP metrics, not by actual latency. A user’s ISP might peer with a CDN POP that is geographically distant but has a short AS path. Cloudflare Argo Smart Routing and AWS Global Accelerator add a measurement layer: they probe actual round-trip latency from many POPs continuously and route traffic over a private backbone (bypassing the public internet) to the lowest-latency POP. Typical saving: 30–50% reduction in p95 latency on intercontinental hops. Cost: per-GB premium pricing for backbone traversal. Worth it for latency-sensitive APIs; usually overkill for static-asset delivery.
A user in Toronto uses 8.8.8.8 as their DNS resolver. Why might they land on a US West Coast CDN POP instead of a Toronto one?
What is the main limitation of pure Anycast routing for CDN proximity?
Trace how a London user reaches the correct CDN edge with GeoDNS.
Order a request path using Anycast routing (no GeoDNS involved):
- 1 Browser issues DNS query — resolver walks to CDN authoritative NS
- 2 Authoritative NS returns the single Anycast IP (same IP for all regions)
- 3 Browser's TCP SYN packet enters the internet with that destination IP
- 4 ISP routers apply BGP forwarding: forward toward the CDN AS advertising the shortest path
- 5 Packet arrives at the CDN POP with the shortest BGP path from this ISP
- 6 TLS handshake + HTTP request completes at that POP
- 01Explain in two sentences why Anycast routing and GeoDNS solve the same problem but fail in different ways.
- 02What does EDNS Client Subnet do, and what is the privacy cost?
- 03A CDN operator discovers their London POP is experiencing high packet loss. How do they stop new users from landing there, and how fast does it take effect?
Anycast and GeoDNS are the two proximity routing mechanisms CDNs use to send every user to the nearest edge server. Anycast advertises one IP from all POPs and lets BGP pick the closest by hop count — automatic and DDoS-resilient, but not perfectly latency-optimal. GeoDNS returns different A records per resolver geography — explicit and fast to change, but only as accurate as the resolver’s location relative to the user. Most CDNs combine both: Anycast for scale and DDoS absorption, GeoDNS for failover control, and optionally smart routing (Cloudflare Argo, AWS Global Accelerator) over a private backbone to correct for BGP’s latency blindspot.
appears again in162
- The journey of a request: seven stops from socket to responsejunior
- Accept and parse: from kernel queue to a typed requestmiddle
- Routing and middleware: choosing what runs, and in what ordermiddle
- Handler and response: from business logic to bytes on the wiremiddle
- Streaming and backpressure: when the client reads slower than you writesenior
- Timeouts and tail latency: budgets, deadlines, and the fan-out trapsenior
- Middleware and DI: the two patterns that shape every backendjunior
- Writing middleware: signatures, next(), and the three framework modelsmiddle
- Inversion of control: how dependencies reach a classmiddle
- DI scopes and lifecycles: singleton, request, transientmiddle
- DI as a testing seam: fakes, mocks, and the boundary that matterssenior
- DI containers in production: resolution graphs, circular deps, and when not tosenior
- Blocking vs non-blocking I/O: two ways to waitjunior
- The event loop: one thread, ordered phasesmiddle
- What blocks the loop: CPU work and sync callsmiddle
- Offloading CPU work: worker threads and the libuv poolmiddle
- Backpressure and bounded concurrencysenior
- Throughput under load: tail latency and saturationsenior
- Why pool: the cost of creating a connectionjunior
- Pool sizing: why bigger is not fastermiddle
- Acquisition and timeouts: the wait queue is the real latency dialmiddle
- Retry strategies: backoff, jitter, and thundering herdmiddle
- Observability, production failures, and global-scale designsenior
- Tasks, microtasks, and scheduler.yield()middle
- Timer accuracy, throttling, and idle workmiddle
- Node.js event loop: phases, nextTick, and loop lagsenior
- Rendering strategies: SSG, SSR, ISR, streaming, and hydrationjunior
- SSG, SSR, ISR, streaming, and RSC — how each worksmiddle
- Hydration cost: selective, progressive, islands, resumabilitymiddle
- Core Web Vitals: what LCP, INP, and CLS measurejunior
- LCP: four phases, one dominant costmiddle
- INP: input delay, processing, presentationmiddle
- Lab vs field: why the two disagree and how to use eachmiddle
- 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 an index is and how it speeds up queriesjunior
- The leading-column rule and composite index designmiddle
- Partial, expression, and covering indexesmiddle
- Index types: GIN, GiST, BRIN, Hash, Bloom, and HOT updatesmiddle
- Index-only scans, the Visibility Map, and INCLUDEsenior
- Production failure modes and the index audit playbooksenior
- Index design exercise: full-text search strategysenior
- EXPLAIN and execution plans: what the planner decides and whyjunior
- Scan types: Seq, Index, Bitmap, Index-Onlymiddle
- Join algorithms and the row-estimate cascademiddle
- pg_statistic, ANALYZE, and production observabilitymiddle
- Extended statistics: fixing correlated-column estimate failuressenior
- Plan cache, cost-constant tuning, and planner internalssenior
- Production failure modes and plan stabilitysenior
- 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
- 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
- Migration failure taxonomy and production disciplinesenior
- Shard-key selection: hash, range, list, and directory strategiesmiddle
- Co-location and Citus: the invariant that makes sharding usablemiddle
- The hot-shard failure mode: detection, isolation, and durable policymiddle
- 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
- What the three signals are: logs, metrics, and tracesjunior
- Metrics and cardinality: the cost model of a time-series databasemiddle
- Logs and volume: the cost model of structured loggingmiddle
- Traces and sampling: the cost model of distributed tracingmiddle
- Join keys and exemplars: making the three signals composemiddle
- Observability 2.0: wide events and the cost shiftsenior
- Failure modes and engineering practice: cardinality budgets, PII, and samplingsenior
- Why structured logs exist: the diary vs the spreadsheetjunior
- The production log schema: fields every line must carrymiddle
- Log levels and alert routingmiddle
- Sampling strategies and log costmiddle
- PII redaction and log injectionsenior
- Trace context propagation in logssenior
- OTel Logs Data Model and audit logs as a subsystemsenior
- OTel signals, Semantic Conventions, and the OTLP wire formatmiddle
- Auto-instrumentation and manual spans: the 80/20 of OTelmiddle
- The OTel Collector: receivers, processors, exporters, and deployment patternsmiddle
- Sampling strategies: head, tail, and parent-basedmiddle
- Vendor neutrality, eBPF instrumentation, the Operator, and browser/serverless OTelsenior
- Operating the OTel Collector: reliability, version skew, failure modes, and governancesenior
- RED and USE: two checklists, one triage disciplinejunior
- Instrumenting RED in Prometheus: counters, histograms, and cardinality disciplinemiddle
- USE on Linux: CPU, memory, disk, network, and PSImiddle
- Golden signals, dashboard layout, and service mesh auto-REDmiddle
- Cardinality as a cost driver: labels, PII, exemplars, and samplingmiddle
- Native histograms, SLO tie-in, and production failure patternsmiddle
- Choosing SLIs and SLO targets: ratios, not feelingsmiddle
- Multi-window multi-burn-rate alerting: why AND beats ORmiddle
- Error budget policy, latency SLOs, and composite journeysmiddle
- Iceberg SLIs, composite SLO math, and SLA vs SLOsenior
- Flame graphs: reading the picture that shows where time goesjunior
- Sampling vs instrumentation profiling: why 99 Hz wins in productionmiddle
- Profile types: CPU, memory, off-CPU, mutex — which one to reach formiddle
- Continuous profiling: always-on flame graphs with eBPF and trace-id correlationmiddle
- How flame graphs are built from samples, and the production workflows that use themmiddle
- Linux perf, eBPF internals, PGO, and the limits of samplingsenior
- Profiling in production: security, war stories, OTel profiles, and the infrastructure designsenior
- The debugging funnel: SLO → RED → trace → profilejunior
- OTel architecture: one SDK, four signals, one wire formatmiddle
- Cost discipline: keeping observability under 5% of infra spendmiddle
- Scale, security, and the ROI of observable systemssenior
- Why profile first: measure where time actually goesjunior
- Amdahl''''s law and self-time: the ceiling on every speedup you can shipmiddle
- The measurement loop: microbench, macrobench, prod profile, observer effectmiddle
- Reading flame graphs: shapes, per-language profilers, and the 60-second scanmiddle
- Statistical baselines: why one run is not a measurementmiddle
- Profiler history and microbenchmark pitfalls: Knuth to GWPsenior
- Hardware counters, cold-start profiles, and profile securitysenior
- Continuous profiling at scale: costs, CI gates, trace correlation, and anti-patternssenior
- What makes a hot path: symptom vs causejunior
- Five shapes of hotspot: CPU, alloc, cache, lock, syscallmiddle
- Reading parent and child chains: where to apply the fixmiddle
- JIT deopt, the fix-and-verify loop, and PR-time profilingmiddle
- Hardware counters and Intel TMA: sub-category diagnosissenior
- False sharing and native-bridge hot pathssenior
- Hot paths in production: security, tail latency, and tooling lineagesenior
- Memory hierarchy: why the same O(N) loop can be 17x slowerjunior
- Row-major vs column-major: access order and the 9x gapjunior
- Branch prediction and branchless codemiddle
- Hardware prefetcher, TLB, and memory-level parallelismsenior
- GC basics: what the runtime taxes you forjunior
- GC algorithms: generational, concurrent, and per-runtimemiddle
- GC tradeoffs: pause, throughput, heap — and object poolingmiddle
- GC tuning: pacing, heap shape, and allocation observabilitymiddle
- GC internals: tri-color invariant, write barriers, and per-runtime deep-divessenior
- GC in production: observability, security, edge cases, and fleet governancesenior
- N+1: one logical operation, many round-tripsjunior
- Fix families: JOIN, IN, preload, and DataLoadermiddle
- Detecting N+1: query logs, APM traces, and CI gatesmiddle
- DataLoader: batching across resolver treesmiddle
- Cross-protocol N+1: HTTP fan-out and Redis MGETmiddle
- N+1 at scale: pool exhaustion, plan changes, and denormalisationsenior
- 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
- What a bundle actually costs: download, parse, compile, executejunior
- Core Web Vitals: LCP, INP, and CLSmiddle
- Code splitting: route-level, component-level, vendor splittingmiddle
- Tree shaking and compression: removing what you don''''t usemiddle
- Third-party scripts: the silent budget killermiddle
- 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