Performance
What a bundle actually costs: download, parse, compile, execute
A developer ships a new feature on a Friday. On their MacBook the page loads in 800 ms — feels fine. By Monday, bounce rate is up 20%. A colleague tests on a mid-range Android phone and watches the page sit blank for 8 seconds. The feature was fine. The bundle was not.
Four phases, one cost
When a browser downloads a JavaScript file, it does not just “load” the code. It runs four sequential phases before a single user interaction is possible.
Download — the bytes travel over the network. On a 4G connection, 200 KB gzip’d takes 150-500 ms depending on signal quality.
Parse — the JS engine walks every byte and builds an abstract syntax tree (AST). V8 parses at roughly 1-2 MB/sec on a fast laptop CPU, but only 200-400 KB/sec on a median Android device. A 500 KB uncompressed bundle takes about 1.5-2 seconds to parse on mid-range mobile.
Compile — the engine converts the AST to bytecode, then to optimised machine code. V8 uses a tiered pipeline (Ignition → Sparkplug → TurboFan). Compile cost grows roughly linearly with how much code actually runs at startup.
Execute — the bundle’s top-level code runs synchronously: framework initialisation, store creation, route registration. For a typical React + Redux app this blocks the main thread for 100-500 ms.
The full chain on mid-range mobile for a 500 KB uncompressed bundle: download 800 ms + parse 1.5 s + compile 300 ms + execute 400 ms = roughly 3 seconds before the user can click anything. Each phase is a separate lever; none of them helps unless you address it directly.
| Phase | Bottleneck | Mid-range mobile cost (500 KB uncompressed) |
|---|---|---|
| Download | Network bandwidth | ~800 ms on 4G |
| Parse | CPU — V8 walks every byte | ~1.5-2 s |
| Compile | CPU — JIT tiers | ~300 ms |
| Execute | CPU — single-threaded startup | ~400 ms |
Why “works on my laptop” fails
A developer’s MacBook M-series has a single-thread CPU speed roughly 4-8x faster than a median Android phone (Snapdragon 6 or 7-series equivalent). A 5G or Wi-Fi connection helps with download — but parse, compile, and execute happen entirely on the user’s CPU. Faster network does not move that needle at all.
Most users in global markets are on mid-range or older hardware. Teams that test only on flagship phones or development machines systematically underestimate real-user experience. Chrome DevTools has a 4x CPU throttling mode that approximates mid-range Android; using it for every performance check catches the gap before it reaches production.
The bundle-budget discipline
A bundle budget is a maximum number of bytes (typically gzip’d JS, CSS, images split separately) that a route is allowed to ship, enforced at CI time. Without a budget, bundle size grows by accretion: each engineer adds a library, each library adds a few KB, no single PR is to blame, but after six months the bundle has doubled. With a budget, every PR that pushes past the cap fails CI — the team either justifies the addition or finds a smaller alternative.
The budget converts performance from an intention into a constraint. It does for client-side bytes what an SLO does for server-side latency: makes it measurable, enforced, and owned.
Why this works
Why does a 1 MB JS bundle cost more than a 1 MB image? An image is downloaded, decoded by the GPU, and painted. JS is downloaded, then parsed, compiled, and executed on the CPU — three extra phases that are slow, sequential, and block the main thread. Per byte, JS is roughly 5-10x more expensive than an image on mid-range mobile.
A 500 KB uncompressed JS bundle loads fine in 400 ms on a dev laptop. Estimate the likely Time to Interactive on a mid-range Android on 4G.
Order the JS bundle lifecycle from network request to first user interaction:
- 1 Browser requests the JS file from the server
- 2 Server returns the file (often gzip or brotli compressed)
- 3 Browser decompresses and receives bytes
- 4 JS engine parses bytes into an abstract syntax tree (AST)
- 5 JS engine compiles the AST into bytecode and then optimised machine code
- 6 Browser executes top-level code: imports, side effects, framework init
- 7 App reaches interactive state — user can click
A team switches from gzip to brotli compression and the bundle goes from 180 KB to 150 KB transferred. LCP improves by 50 ms. Is the bundle problem solved?
- 01Name the four phases a JS bundle goes through before a page is interactive.
- 02Why does a 4G upgrade not fix parse and compile times?
- 03What is a bundle budget and what does it prevent?
A JavaScript bundle triggers four sequential CPU phases: download, parse, compile, execute. The first is network-bound; the other three are CPU-bound and run 4-8x slower on a median Android than on a dev laptop. A 500 KB uncompressed bundle can cost 3 seconds of blocked main thread on mid-range mobile — invisible in development. Bundle budgets make the cost a per-route constraint enforced at CI, catching drift before it reaches users. The next lesson connects these costs to Google’s Core Web Vitals and the concrete thresholds that define “good” vs “poor” for LCP, INP, and CLS.
appears again in159
- 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
- Bits on the wirejunior
- Latency mathmiddle
- Bufferbloat and congestionsenior
- The physical frontiersenior
- Sequence numbers and connection statemiddle
- Flow control and congestion controlmiddle
- BBR, production observability, and beyond TCPsenior
- CDN: putting content next doorjunior
- Anycast and GeoDNS: routing to the nearest edgemiddle
- Tiered cache and Cache-Controlmiddle
- Vary header and cache keysmiddle
- Stale-while-revalidate and cache stampedesenior
- Edge workers and edge-side compositionsenior
- CDN operations and observabilitysenior
- WebSocket: the HTTP upgrade handshakejunior
- WebSocket vs SSE vs long-polling: choosing the right transportmiddle
- WebSocket backpressure: when clients can''''t keep upmiddle
- Reconnection: jittered backoff, thundering herd, message resumptionsenior
- WebSocket at scale: HTTP/2 multiplexing, permessage-deflate, C10Msenior
- WebSocket in production: proxies, security, and distributed architecturesenior
- What reverse proxies dojunior
- Balancing algorithms: round-robin to power-of-two-choicesmiddle
- L4 vs L7 load balancing and client-IP preservationmiddle
- Health checks, connection draining, and slow startmiddle
- Retry storms, circuit breakers, and load sheddingsenior
- Resilient LB architecture: anycast, zone-aware routing, and observabilitysenior
- Why QUIC and not TCP+TLSjunior
- QUIC streams and head-of-line blockingjunior
- Integrated handshake and 1-RTTmiddle
- Connection IDs and network migrationmiddle
- Loss detection and congestion controlmiddle
- 0-RTT resumption and packet encryptionsenior
- Deployment tradeoffs and CPU costsenior
- DDoS: what it is and why it worksjunior
- Amplification attacks and state exhaustionmiddle
- Rate limiting: algorithms and architecturemiddle
- WAFs, firewalls, mTLS, and HSTSmiddle
- DNS cache poisoning and BGP hijackingsenior
- Defense-in-depth architecture and attack economicssenior
- The twelve layers: one URL, seven actorsjunior
- DNS, TCP, TLS in sequence: where the milliseconds gomiddle
- Critical render path and Core Web Vitalsmiddle
- Proxy intercepts and security gates: rate limiters, WAF, mTLSmiddle
- Alternate paths: QUIC 0-RTT, WebSocket upgrade, connection migrationmiddle
- Observability: distributed traces, USE/RED, and samplingsenior
- Resilience: cascading retries, circuit breakers, and error budgetssenior
- 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