Networking & Protocols
Vary header and cache keys
Your CDN hit rate is 5% despite setting max-age=3600. The dashboard shows thousands of unique cache entries per URL. Somewhere in the origin response headers there is a Vary line that is silently fragmenting every URL into thousands of separate cache keys — one per unique browser header combination. This is the most common CDN misconfiguration in production.
How the cache key is built
A CDN cache stores responses indexed by a cache key. The default key is (URL, HTTP method, Host). The Vary response header extends the key with additional request header dimensions:
Cache-Control: public, max-age=3600
Vary: Accept-Encoding, Accept-LanguageThis tells the cache: maintain separate entries for each distinct value of Accept-Encoding and Accept-Language. A request for /page with Accept-Language: en and another with Accept-Language: ru create two separate cache entries — both correct language versions are served from cache.
RFC 7234 §4.1 formalises this: “A cache MUST use the value of the Vary header field to determine if a stored response may be used for a given request.”
The Vary footgun
Vary works correctly for Accept-Encoding (gzip vs brotli — ~5 distinct values) and Accept-Language (~10–50 values per site). But some headers have thousands or millions of distinct values:
| Vary header | Distinct values | Effect |
|---|---|---|
Accept-Encoding | ~5 (gzip, br, identity…) | Safe — small fragmentation |
Accept-Language | ~50 per typical site | Usually fine |
User-Agent | Thousands (every browser × version × OS) | Cache destroyed |
Cookie | Per-user (millions) | Effectively uncacheable |
Authorization | Per authenticated user | Effectively uncacheable |
Vary: User-Agent is the classic footgun: developers add it to serve different HTML for mobile vs. desktop. The result is one cache entry per unique User-Agent string — every Chrome release, every iOS version, every Safari build. The cache fills up with unique entries that will never be reused; hit rate plummets to near zero.
- No Vary (or Vary: Accept-Encoding only)
- 90–98% hit rate (normal operation)
- Vary: Accept-Language added (10 values)
- 80–90% — small fragmentation
- Vary: User-Agent added
- <10% — near-zero effective caching
- Vary: Cookie added
- ~0% — per-user entries never reused
- Vary: Authorization added
- ~0% — per-token entries never reused
Cache key surprises
1/3Cookies are NOT in the cache key by default
This is the most security-relevant Vary fact. Cookies are not part of the default cache key. If an endpoint reads a session cookie and returns personalised content:
- Missing
Cache-Control: private→ CDN caches the personalised response - Missing
Vary: Cookie→ different users with different cookies get the same cached response
Result: one user’s account page is served to another user — a data leak.
Rule of thumb: for any endpoint that reads a cookie, set Cache-Control: private. Only use Vary: Cookie if you need CDN caching for cookie-differentiated content (rare, complex, requires a cookie whose value is stable and low-cardinality).
Edge cases
Cache poisoning via unkeyed headers. James Kettle’s research (PortSwigger, 2018) documented how CDNs can be tricked into caching a malicious response. If the origin reads a request header (e.g. X-Forwarded-Host) to build the response body, but that header is NOT included in the CDN’s cache key (not in Vary), an attacker can send a crafted request with X-Forwarded-Host: evil.com — origin returns a page with evil.com links, CDN caches it by URL only, and serves the poisoned page to all subsequent users. Mitigation: keep CDN and origin tightly aligned on which headers are key-significant; strip unrecognised forwarding headers at the CDN edge; use cache-key normalisation to drop non-significant query params.
What does Vary: Accept-Encoding actually do in a CDN cache?
What is the practical effect of Vary: Authorization on a shared CDN cache?
Order these Vary header values from safest (least cache fragmentation) to most dangerous (most fragmentation):
- 1 Vary: Accept-Encoding — ~5 distinct values (gzip, brotli, identity, deflate, none)
- 2 Vary: Accept-Language — ~10–50 values per typical site
- 3 Vary: Accept — content-type negotiation, ~5–10 values
- 4 Vary: User-Agent — thousands of unique values across browsers and versions
- 5 Vary: Cookie — potentially millions of unique values (one per active session)
- 01Explain why Vary: Accept-Encoding is required for an endpoint that serves gzipped responses to some clients and uncompressed to others.
- 02A news site's article page has Vary: User-Agent to serve different layouts for mobile vs. desktop. Cache hit rate is 3%. What is the root cause and how do you fix it?
- 03Why are cookies not in the default CDN cache key, and what is the security risk this creates?
The CDN cache key is built from the URL, HTTP method, Host, and any request headers listed in the response’s Vary header. Vary: Accept-Encoding is safe — only ~5 possible values. Vary: Accept-Language is usually safe — ~10–50 values. Vary: User-Agent is catastrophic — thousands of unique Browser×version×OS combinations, each becoming a separate cache entry that is never reused, collapsing hit rates to near zero. Cookies are NOT part of the default key, which is an efficiency choice that creates a security risk: endpoints that serve personalised content without Cache-Control: private can leak one user’s response to another. Audit every route that reads cookies or auth headers and mark it private or no-store.
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