Networking & Protocols
CDN: putting content next door
Crux A CDN moves copies of your content to hundreds of edge servers worldwide so each user fetches from a server 20 ms away instead of 200 ms.
Your altitude — climbing toward senior
ZeroJuniorMiddleSenior
You are at junior altitude — the surfaceWhen Bea in London loads a page whose server sits in California, every request travels 200 ms round-trip — and nothing in your code can fix that. The speed of light is finite. A CDN closes the gap by moving content, not by speeding up the network.
What a CDN does in one sentence
A CDN (Content Delivery Network) keeps copies of your website on hundreds of servers around the world so the user’s browser fetches bytes from a server 20 ms away instead of one 200 ms away.
Why latency is the real problem
Speed of light is ~300,000 km/s in vacuum; in fiber it’s slower (~200,000 km/s). London to California is ~8,700 km. The one-way minimum is 8,700 / 200,000 = ~43 ms. Round-trip: ~87 ms. Add TCP handshake, TLS, queuing — you’re at 200–250 ms per request. No code optimisation closes that gap. A CDN closes it by moving the content.
The warehouse metaphor
Imagine you publish a magazine. Without a CDN you mail every reader a copy from one print shop. With a CDN you ship pallets to local distribution centres in every city; each reader picks up a copy from their nearest one. Same magazine, far shorter trip. Each Point of Presence (PoP) is one of those warehouses — a data center with CDN servers.
One scenario end to end
Bea in London navigates to a CDN-fronted site:
- Browser does DNS — returns the IP of the nearest CDN edge server (either via Anycast routing or GeoDNS).
- TCP + TLS + HTTP request all happen against the edge, not the origin.
- Cache hit: edge has the page cached → response in ~20 ms.
- Cache miss: edge forwards to origin (or an intermediate shield), caches the answer, returns it.
Patty in Tokyo asks the same URL and lands on the Tokyo edge with its own cached copy. Sven , the origin server in California, sees one request from each city’s edge and almost no traffic from users directly.
- Origin (California → London) round-trip
- ~200–250 ms
- Edge cache hit (London POP)
- ~10–20 ms
- Speed-up factor on a cache hit
- 10–20×
- Cloudflare edge POPs (2026)
- 330+ cities, 120+ countries
- Typical cache hit ratio (static assets)
- 90–98%
- Origin shield traffic absorption
- 90%+ of edge misses
When does a CDN NOT help?
A CDN helps when content can be shared across users — static assets (JS, CSS, images), HTML pages without user-specific data. It does not help when every response is unique (bank balance, personalised feed, checkout total) — there is nothing to cache, so the request still hits origin. The connection still terminates at the edge, which saves TLS setup latency, but the response must be fetched fresh each time.
Why this works
Why three mechanisms work together. Anycast IP routing (same address advertised from many cities) delivers requests to the BGP-nearest POP without any DNS special-casing. GeoDNS adds explicit control: the CDN operator returns different A records by resolver geography, so a London resolver gets a London edge IP. The edge cache then serves most requests without ever contacting the origin. All three cooperate: Anycast or GeoDNS finds the right edge; the cache does the heavy lifting.
Quiz
Completed
What is the main job of a CDN?
Heads-up Encryption is TLS's job, not the CDN's.
Heads-up Many CDNs offer bot protection, but caching is the core purpose.
Heads-up Origin DB is unrelated to CDN edge caching.
Quiz
Completed
When does a CDN NOT reduce latency?
Heads-up That is precisely when CDN helps the most.
Heads-up CDN cannot fix last-mile bandwidth, but still helps with everything before it.
Heads-up CDNs work great with HTTPS — they terminate TLS at the edge.
Order the steps
Completed
Order what happens on a CDN cache HIT:
- 1 Browser DNS resolves to CDN edge IP via Anycast or GeoDNS
- 2 Browser opens TCP + TLS connection to the edge
- 3 Browser sends HTTP request
- 4 Edge looks up the URL in its cache and finds a fresh copy
- 5 Edge returns the cached response to the browser
Complete the analogy
Completed
Fill in the blank: a CDN is like a chain of _______ distributing your content so each user picks up from the closest one.
Answer
warehouses (or distribution centres) — Each edge POP is a small warehouse holding popular content close to local users. Origin is the central factory that wholesales to warehouses.
- 01In one sentence: what trade-off does a CDN ask you to accept in exchange for speed?
- 02Name the two mechanisms a CDN uses to route a user to the nearest edge server.
- 03Why does a CDN still help latency for personalised responses even though it cannot cache them?
Recap
A CDN (Content Delivery Network) replicates content to hundreds of edge Points of Presence (POPs) worldwide so users fetch from a server 20 ms away instead of 200 ms away. Anycast routing or GeoDNS directs each request to the nearest POP; the edge’s local cache serves it without contacting origin. A cache hit is 10–20× faster than an origin round-trip — the win comes entirely from proximity, not from faster hardware. CDNs help most for cacheable content (static assets: JS, CSS, images) and least for personalised responses where caching is impossible. The origin sees only a fraction of total traffic, typically under 10% for a well-configured static site.
Connected lessons
deepens into
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