Skip to content

24. Capstone — One URL, End to End, and Thinking Like a Staff Engineer

“A senior engineer knows how it works. A staff engineer makes sure the right people know, and the right decision gets made.”

The story: the second walk through the city

Section titled “The story: the second walk through the city”

The first time you walk through a new city, you see streets and buildings and crowds. The tenth time, after you’ve lived there a while, you see systems: the bus routes that feed the train stations, the markets that open at 5 a.m. because that’s when the lorries arrive, the reason that one junction always jams at 6 p.m. You can give directions. You can explain why the traffic is bad. You can propose a fix at a town meeting — and argue for it so people agree.

You walked the city once in the Prologue, at fly-over altitude. You’ve now lived in every district. Let’s take the walk again, at full resolution. Then we’ll talk about the town meetings: the skills that turn knowing how it works into changing how it works.

One URL, end to end — at full resolution

Section titled “One URL, end to end — at full resolution”

Priya taps https://lumen.example.in/essays/monsoon in WhatsApp. Here’s every hop, with the chapter that owns it and the question a staff engineer asks at each.

End-to-end journey at full resolutionThree rows of boxes. Row one, build and ship: source, build (hashed chunks, tree-shaking), packages (lockfile), CI (checks, budgets), CD (immutable artifact, canary). Row two, deliver: DNS (TTL), TCP or QUIC and TLS (round trips), CDN edge (cache-control, anycast), origin render (SSG, SSR, streaming), HTML response. Row three, in the browser and after: parse and preload scanner, style layout paint composite, event loop and hydration, interaction (INP), RUM beacon, CrUX and ranking, alerts back to the team. Each box has a short failure note.Build & shipBuild (1)hash · shake · splitside effectsPackages (2)lockfile · scriptspostinstallCI (3)fresh runner · budgetsflaky, slowCD (4)immutable · canaryno rollbackStrategy (7)SSG/SSR/RSChydrate everythingDeliverDNS (5)resolver cachelong TTL movesQUIC/TLS (5)round tripsredirect chainsCDN (6)anycast · cacheno-cache confusionOrigin (6–7)render · streamslow TTFBSecurity (13)CSP · cookies3P scriptsBrowser & afterLoad (8–9)parse · preload scanhidden heroFrames (10)style→compositejank, layersEvent loop (11)tasks · yieldlong tasksMeasure (16–17)RUM · CrUX · p75localhost liesFound/ObservedSEO (22) · alerts (23)noindex, 200-outagewhat you learn in production flows back into the editor
Figure 24.1. The journey at full resolution. Each box is a chapter; each red note is the failure mode you now know how to spot.

Before the tap. Your TypeScript and JSX were transpiled, the module graph bundled, dead code shaken out (except where side effects pinned it), routes split, files content-hashed (Ch 1). Dependencies came from a lockfile, installed cleanly with install scripts restricted (Ch 2). A fresh CI runner linted, type-checked, tested, built, checked bundle budgets and ran Lighthouse (Ch 3). An immutable artifact rolled out via canary with the previous version one command away (Ch 4). The essay routes were statically generated with only the like button and lightbox hydrating; search is streamed SSR (Ch 7).

The tap. The browser process (Ch 8) checks bfcache and prerendered pages (Ch 9) — the essay was prerendered on hover via Speculation Rules, so the navigation is instant. If not: DNS from the resolver’s cache (Ch 5), a QUIC connection with combined transport and TLS handshake to the nearest anycast PoP (Ch 5–6), the HTML served from the edge with stale-while-revalidate (Ch 6), security headers attached (Ch 13).

In the renderer. The parser streams the HTML into a DOM; the preload scanner discovers the hero <img> with fetchpriority="high", the one preloaded font and the deferred module scripts (Ch 9). CSS is small and same-origin, so first paint is quick. Style, layout, paint on the main thread; layerize, raster on the GPU, composite and display (Ch 10). LCP: 1.9 s at p75, mostly TTFB and download.

The interaction. Hydration of the two small islands takes 40 ms on Priya’s phone, in chunks (Ch 7, 11). She taps “Save”: the handler updates the button immediately, yields, then writes to IndexedDB (Ch 12) and syncs via BroadcastChannel to her other tab (Ch 14); focus and announcements are correct (Ch 15). INP: 90 ms.

After. web-vitals beacons her LCP, INP and CLS with attribution on visibilitychange (Ch 16–17). CrUX aggregates real Chrome users; Search Console shows the essay as “Good” (Ch 22). Your dashboards show p75 by route and release; no alerts fire (Ch 23). Next quarter, you’ll read that data, write an RFC, and make it better.

That’s the whole thing. You can draw it.

Knowing the mechanisms makes you senior. Staff is about leverage: making decisions that affect many engineers and many users, and getting them adopted.

An RFC is how you make a decision in writing so it can be reviewed, improved and remembered. A structure that works:

  1. Title, author, status, date, reviewers.
  2. Context — the problem, with evidence (field data, incidents, user feedback). One page max.
  3. Goals and non-goals — what success looks like, measurably; what you’re deliberately not solving.
  4. Proposal — the design, with a diagram (you now have ten whiteboard templates).
  5. Alternatives considered — at least two, with honest trade-offs and why not.
  6. Costs and risks — effort, migration, performance budget impact, security and privacy, operational load, what could go wrong and the rollback plan.
  7. Measurement — how you’ll know it worked (the metric, the target, the timeframe).
  8. Rollout — phases, flags, canaries.
  9. Open questions.

The best RFCs are short, specific and opinionated. The worst are surveys that end with “we could do any of these.”

2. Setting and defending performance budgets

Section titled “2. Setting and defending performance budgets”

You set budgets from user outcomes backwards: “p75 INP ≤ 200 ms on mobile” → “main-thread work at load ≤ X ms on the reference device” → “JS on the critical path ≤ Y KB” (Ch 16, 18). You defend them by showing the chain: this budget protects this metric, which users feel like this, which correlates with this business outcome, and here’s what happened when we broke it. And you make exceptions explicit (owner, reason, expiry) instead of quietly raising limits.

Performance and reliability work competes with features for roadmap time. Product managers think in value and urgency. Frame your work the same way:

  • Value: what does fixing this get us? (“Mobile LCP in ‘poor’ on the product pages, which carry 60% of revenue; published case studies and our own A/B test suggest a few percent conversion lift is plausible.”)
  • Cost of delay: what does waiting cost per week? (“Each week at current traffic, a 2% conversion gap is roughly ₹X; plus Search Console now flags 4,000 URLs as ‘Poor’.”)
  • Effort and risk: honest estimates.
  • Sequencing: the cheapest high-value slice first (“Fixing hero discovery is two days and should move LCP the most”).

Be honest about uncertainty. Leadership trusts the engineer who says “we expect, here’s how we’ll check” over the one who quotes Amazon’s 100 ms.

4. Explaining trade-offs to PMs and leadership

Section titled “4. Explaining trade-offs to PMs and leadership”

Rules that work:

  • Lead with the user and the business, then the mechanism, then the numbers. Never the other way round.
  • One chart, one sentence. A filmstrip or a p75 trend line with a release marker beats a table of twelve metrics.
  • Offer options with trade-offs, and a recommendation. “We can (A) ship as is and accept slower Android, (B) ship with the effect disabled on weak devices, (C) delay a week to share the WebGL context. I recommend B now and C next sprint.”
  • Translate units: not “TBT 600 ms” but “on a typical phone, taps are ignored for about half a second after the page appears.”
  • Say what you don’t know, and how you’ll find out.

Teach the mental models, not the answers: the single cook, latency vs bandwidth, the four LCP slices, the three INP phases, “which thread, which chip.” Pair on real traces. Review PRs with questions (“what’s the main-thread cost of this on the reference phone?”) rather than verdicts. Share incident write-ups. Your goal is a team where performance and reliability are everyone’s reflex, not your specialty.

A recurring (monthly or per-release) 45-minute ritual:

  1. Field first: p75 vitals by route and device class vs targets; trend since last review; any regressions by release (Ch 16–17, 23).
  2. Incidents and alerts: what fired, what was noise, what we learned.
  3. Budgets: bundle and third-party trends; exceptions due to expire.
  4. One deep dive: a trace from the reference phone of a key journey, read together (Ch 10).
  5. Decisions and owners: two or three actions, each with an owner and a date.

Keep it short, keep it about users, keep the action list small. It’s the habit that keeps a fast site fast.

Whiteboard templates: ten diagrams to draw from memory

Section titled “Whiteboard templates: ten diagrams to draw from memory”

Practise each until you can draw it in under a minute and say its sentence. Each one already appeared in its chapter; here they are together, as the minimal version.

Whiteboard templates one to fourFour mini diagrams. One, request lifecycle: DNS, connect, TLS, request, TTFB, download. Two, caching layers: browser memory, disk, service worker, CDN, shield, origin, with hashed immutable and HTML revalidate notes. Three, CI/CD: push, fresh runner checks, artifact, preview, canary, production, rollback arrow. Four, rendering strategies: build time SSG, request time SSR, device CSR, with hydration amount on a second axis.1 · Request lifecycleDNS · TCP · TLS · TTFB (RTT + server) · download2 · Caching layersmemory → disk → SW → CDN → shield → originhashed: max-age=1y, immutableHTML: revalidate (+ s-maxage, swr)3 · CI/CDpushchecksartifactcanary100%rollback = repoint4 · Rendering strategiesbuild (SSG) → request (SSR) → device (CSR)hydration ↑
Figure 24.2. Templates 1–4: the request lifecycle, caching layers, CI/CD, rendering strategies.
Whiteboard templates five to eightFive, rendering pipeline: main thread JS, style, layout, paint; compositor layerize and draw; GPU raster and display; transform and opacity enter at the compositor. Six, event loop: one task, all microtasks, maybe render with rAF, style, layout, paint. Seven, Core Web Vitals: LCP split into four sub-parts, INP into three phases, CLS as largest shift window, thresholds 2.5 seconds, 200 milliseconds, 0.1 at p75. Eight, browser processes: browser, GPU, network, sandboxed renderers per site.5 · Rendering pipelinemain: JS · style · layout · paintcompositorGPUtransform/opacity enter at the compositor6 · Event loop1 taskall microtasksmaybe renderrAF → style → layout → paint; long task blocks both7 · Core Web VitalsLCP ≤ 2.5 sINP ≤ 200 msCLS ≤ 0.1 (largest window)p75 · mobile and desktop separately8 · Browser processesbrowserGPUnetworksite Asite Biframe Crenderers sandboxed, one per site
Figure 24.3. Templates 5–8: the rendering pipeline, the event loop, the Core Web Vitals breakdown, browser processes.
Whiteboard templates nine and tenNine, GPU pipeline: buffers, vertex shader, rasterize, fragment shader, framebuffer, with notes that draw calls cost CPU and pixels cost GPU. Ten, measurement loop: field data shows the problem, lab traces explain it, fix one thing, budgets in CI lock it in, back to field.9 · GPU pipelinebuffersVSrasterFSframedraw calls cost CPU · pixels cost GPUone context, instancing, right-size textures10 · Measurement loopfield: whatlab: whyfix one thingbudget in CI
Figure 24.4. Templates 9–10: the GPU pipeline, and the measurement loop (lab microscope, field verdict, budgets).
  1. The request lifecycle — “Before a byte arrives we pay round trips for DNS, connect and TLS; on mobile, latency sets the pace.” (Ch 5)
  2. Caching layers — “Hashed assets cached forever, HTML revalidated; every cache between user and origin follows our headers.” (Ch 6)
  3. The CI/CD flow — “A fresh runner checks every push; an immutable artifact rolls out gradually; rollback is repointing.” (Ch 3–4)
  4. Rendering strategies — “Decide per route when HTML is made, then hydrate as little as possible.” (Ch 7)
  5. The rendering pipeline — “Main thread does JS, style, layout, paint; compositor and GPU do the rest; animate what the compositor can move alone.” (Ch 10)
  6. The event loop — “One task, then all microtasks, then maybe a frame; long tasks block input and rendering.” (Ch 11)
  7. The Core Web Vitals breakdown — “LCP’s four slices, INP’s three phases, CLS’s largest window, judged at p75.” (Ch 16)
  8. Browser processes and threads — “Each site gets a sandboxed process; inside, one main thread and an independent compositor.” (Ch 8)
  9. The GPU pipeline — “Tiny programs per vertex and per pixel; briefings cost CPU, pixels cost GPU.” (Ch 20)
  10. The measurement loop — “Field tells us what, lab tells us why, we fix one thing, and budgets keep it fixed.” (Ch 16–18)

Forty questions you might face in senior and staff frontend interviews — or in a design review on a Tuesday. Answer out loud before opening each model answer. The model answers are deliberately compact; a great real answer adds a diagram and an example from your own work.

1. Walk me through what happens between pressing Enter on a URL and seeing pixels.

Navigation checks (bfcache, prerender, service worker) → DNS → TCP+TLS or QUIC → request to CDN edge → cache hit or origin render → HTML streams → parser builds DOM, preload scanner fetches subresources → CSS blocks render, scripts per async/defer → style, layout, paint on main → layerize, raster, composite on compositor/GPU → display. Name the round trips and where latency dominates.

2. Why does tree-shaking sometimes fail?

Side effects (modules mutating globals, importing CSS), CommonJS (dynamic require defeats static analysis), and missing sideEffects hints. The bundler keeps anything it can’t prove is safe to remove.

3. Why is Vite’s dev server unbundled but its production build bundled?

Localhost round trips are free, so serving native ESM gives instant start and fast HMR; production round trips cost real latency, so bundling, splitting and hashing pay off.

4. What does a lockfile guarantee, and why use a clean install in CI?

Exact versions and integrity hashes for the whole tree; a clean install reproduces it exactly and fails on drift instead of silently updating.

5. How would you defend against a compromised npm package?

Lockfiles and clean installs, block install scripts by default, minimum release age, automated but reviewed updates, least-privilege CI (no secrets in install jobs), fewer dependencies, provenance and trusted publishing for our own packages, and an incident runbook to rotate secrets.

6. Design a CI pipeline for a Next.js app.

On PR and main: checkout, cached frozen install, lint, typecheck, unit tests (parallel job), build, bundle-size check, Lighthouse CI on key routes, preview deploy; required checks and branch protection; separate deploy job with OIDC credentials.

7. Blue-green vs canary — when each?

Blue-green for fast, atomic switches with easy rollback when you can afford duplicate environments; canary when you want to limit blast radius and validate with real traffic metrics progressively. Flags decouple release from deploy for both.

8. How do you change a database column without breaking rollback?

Expand/contract: add new column, write both, backfill, switch reads, stop writing old, drop later — each step independently deployable and reversible.

9. What leaks if a secret is put in a NEXT_PUBLIC_ variable?

It’s inlined into client bundles at build time and readable by anyone; rotate it immediately and move the call server-side.

10. Why does latency matter more than bandwidth on mobile?

Page loads are chains of mostly small, sequential round trips (DNS, handshakes, discovery); each costs a full RTT regardless of size, and slow start limits early throughput anyway.

11. What did HTTP/2 fix and what did HTTP/3 fix?

HTTP/2: multiplexing many requests on one connection and header compression, removing application-level HOL blocking. HTTP/3 over QUIC: removes TCP-level HOL blocking (per-stream loss recovery), faster handshakes, connection migration.

12. Explain no-cache vs no-store vs immutable.

no-cache: store but revalidate before every use. no-store: never store. immutable: won’t change during freshness; don’t revalidate even on reload. Use immutable for hashed assets, revalidation for HTML, no-store for sensitive data.

13. How do you choose between SSG, SSR and CSR?

Per route: same-for-everyone and rarely changing → SSG; same but changing → ISR/edge-cached; personalized → streaming SSR; logged-in, highly interactive, not indexed → CSR with a fast shell. Then minimize hydration.

14. What is hydration and why is it expensive?

Re-running components on the client to rebuild the framework’s tree and attach handlers to server HTML — rendering twice, on the user’s slowest computer, often as a long task that blocks input.

15. What’s the RSC payload?

A serialized description of the server-rendered component tree with references (holes) for client components and their props, used to build the client tree and for client navigations without shipping server component code.

16. Why do browsers use multiple processes, and what did Spectre change?

Stability and sandboxing; Spectre showed same-process data can leak via CPU side channels, so different sites must be in different processes (site isolation).

17. Why does a transform animation stay smooth when the main thread is busy?

Native transform/opacity animations on a composited layer are run by the compositor thread, which updates property trees and draws frames without main-thread style/layout/paint.

18. A route change feels janky. How do you investigate?

Record a production build trace with throttling (or on a real phone); split into network wait, script eval, framework render/commit, style/layout, paint/raster/decode, font swap, shifts, GC; find long tasks and dropped frames; fix the biggest (prefetch, split, yield, compositor-only transitions, reserve space).

19. What is layout thrashing and how do you fix it?

Interleaving DOM writes with layout reads forces synchronous layout each iteration; batch reads before writes, cache measurements, use observers, schedule writes in rAF.

20. What does content-visibility: auto do?

Skips style, layout and paint for off-screen subtrees until needed; pair with contain-intrinsic-size to avoid scrollbar jumps.

21. Why are backdrop-filter blurs expensive?

Each frame the content behind must be captured to an offscreen texture and blurred in multiple GPU passes; cost grows with area and radius, and moving content behind forces recomputation every frame.

22. Order these: setTimeout callback, promise.then, rAF callback, sync log.

Sync log, then promise.then (microtask), then either setTimeout or rAF depending on whether a frame is due — rAF runs in the rendering steps before paint; the timeout is a separate task.

23. How do you keep a long computation from hurting INP?

Chunk it and yield (scheduler.yield or setTimeout), prioritize the visible update first, or move it to a worker with transferables.

24. When is SharedArrayBuffer available, and why?

Only on cross-origin isolated pages (COOP same-origin + COEP), because shared memory enables high-resolution timers useful for Spectre-style attacks.

25. Where should a session token live?

In an HttpOnly, Secure, SameSite=Lax (or Strict) cookie — not localStorage, which any XSS can read.

26. Users are stuck on an old version of your PWA. Why, and how do you fix it?

Cache-first HTML in the service worker, a waiting worker that never activates, or a long-cached sw.js. Network-first or SWR for navigations, no-cache on sw.js, an update prompt with skipWaiting, and a kill-switch worker.

27. Why does “just add Access-Control-Allow-Origin: *” fail with cookies?

Credentialed requests require an explicit origin and Allow-Credentials: true; the wildcard is forbidden because it would let any site read responses made with the user’s cookies.

28. Where doesn’t React protect you from XSS?

dangerouslySetInnerHTML, javascript: URLs in href, direct DOM writes via refs, unescaped inline JSON in script tags, and third-party scripts.

29. What must an SPA do on route change for accessibility?

Move focus to the new view’s heading (or main), update document.title, optionally announce via a live region, and restore focus/scroll on Back.

30. Name the Core Web Vitals and thresholds, and explain p75.

LCP ≤ 2.5 s, INP ≤ 200 ms, CLS ≤ 0.1; a page passes if the 75th percentile of real visits meets each, separately for mobile and desktop.

31. LCP is 4.1 s at p75 on mobile but 1.2 s in your Lighthouse run. Explain and plan.

Lab is one profile, cold, often a faster machine and network; field reflects real devices, networks and content. Break down field LCP by sub-part with RUM attribution, reproduce on a real mid-range phone, fix the largest slice (often discovery or TTFB), verify in the field over weeks.

32. What are the four LCP sub-parts and what fixes each?

TTFB (CDN, caching, SSG, streaming), resource load delay (discoverable img, no lazy, fetchpriority, preload), load duration (format, size, image CDN), render delay (less blocking CSS/JS, avoid CSR for the hero, no long tasks).

33. What are the three phases of an interaction’s latency?

Input delay (main thread busy), processing (handlers), presentation delay (style, layout, paint until the next frame).

34. A page uses 688 CPU ms/s at idle and runs at 41 FPS. What does that mean and what do you do?

The main thread is ~69% busy at steady state — little input headroom, INP risk, visible stutter, and worse on slower devices. Pause off-screen work, reduce live effects, share GPU contexts, move work off-thread, and degrade on weak devices; re-measure.

35. How do you test on a real Android phone?

Enable developer options and USB debugging, connect, open chrome://inspect, inspect the tab, record a Performance trace on the device over its own network, using a production build.

36. How would you set up RUM?

web-vitals with attribution, beacon on page hide to an endpoint, store with route/device/connection/release dimensions, compute p75 per segment, alert on regressions, minimize and scrub personal data.

37. Should we add this third-party script?

Only with a budget: measure its main-thread and network cost on a reference phone, load it async/after interaction or behind a facade, check privacy and security (CSP, SRI), assign an owner, and verify field impact.

38. What’s FLIP and why does it work?

First, Last, Invert, Play: compute layout once, then animate a transform from the old position to the new — compositor-friendly motion for layout changes.

39. CSS, SVG, Canvas, WebGL or WebGPU for a 200,000-point interactive scatter plot?

WebGL (or WebGPU with fallback) for rendering, with DOM controls and an accessible summary/table; SVG would create 200k nodes, Canvas 2D may struggle with interaction at that scale.

40. Organic traffic dropped 70% over three weeks after a redesign. What do you check first?

Search Console URL inspection and indexing report: accidental noindex or robots.txt Disallow from staging, canonicals pointing to wrong URLs, redirects broken or 302, soft 404s, content now client-rendered only. Then add CI guards and monitoring.

Warm-up 1. Draw them. Draw all ten whiteboard templates from memory in 15 minutes. Compare with this chapter.

Self-check

Any you couldn’t draw: reread that chapter’s Whiteboard box and redraw tomorrow.

Warm-up 2. One-sentence answers. For five gauntlet questions, write your answer in one sentence, then in one minute out loud.

Self-check

Record yourself. Did you lead with the user, then the mechanism, then a number?

Warm-up 3. Translate. Rewrite “TBT is 640 ms and LCP render delay is 1.1 s” for a PM.

Model answer

“On a typical phone, the main content appears about a second later than it could because our JavaScript is busy, and taps are ignored for around half a second after the page shows up.”

Lab 4. Lumen’s final audit. Run the full measurement loop on Lumen: field data (your RUM), lab traces on a real phone, Lighthouse in CI, bundle budgets. Produce a one-page status report.

Expected outcome

A report like Chapter 16’s audit, for your own app: what’s good, what’s at risk, what’s next.

Lab 5. Lumen’s RFC. Write an RFC for one improvement to Lumen (e.g., replacing the WebGL hero with a shared-context design, or adding offline reading) using the template above.

Self-check

Does it include evidence, alternatives, measurement and a rollback plan? Would a reviewer understand it without you?

Lab 6. Run a perf review. Run the 45-minute performance review ritual with a friend or colleague on Lumen or a real product. Produce three actions with owners and dates.

Expected outcome

A short written record; next month, check whether the actions moved the numbers.

Lab 7. Incident drill. Break Lumen deliberately in a preview environment (ship a noindex, a 200-blank page, a long task in a click handler). Check whether your monitoring catches each within the time you’d want.

Expected outcome

Gaps in monitoring become visible; fix them before production finds them for you.

Staff 8. The performance budget RFC. Write a one-page RFC proposing a performance budget for your team: metrics, targets, enforcement, exceptions, review cadence, and the business case.

Model outline

Context with field data; goals (p75 vitals on mobile); quantity budgets per route enforced in CI; field monitoring with alerts; exception process with owners and expiry; monthly review; expected business impact stated honestly with a plan to measure.

Staff 9. The laggy dashboard, on a whiteboard. Explain to a PM, using only a whiteboard, why the dashboard feels laggy and what you’ll do about it.

Model answer

Draw the single cook (main thread) with a pile of tasks: data parsing, re-rendering a 5,000-row table, chart redraws. Show a tap waiting behind them. Then draw the fix: virtualized table, chart in a worker/canvas, data prefetched, work chunked with yields. Close with the metric (INP from ~600 to under 200 ms) and how you’ll prove it.

Staff 10. Decide and defend. Your company is launching an e-commerce site in India. Choose CSR or SSR (or a mix) for the product listing and product detail pages, and defend it in a half page.

Model answer

Mix: listing and detail pages server-rendered and edge-cached (ISR) for fast LCP on mid-range Android and SEO; personalization (price for location, cart) streamed or fetched after first paint; client components only for interactive pieces (gallery, add-to-cart); budgets and RUM to verify. CSR would delay content behind JS on the devices and networks most customers use.

You started this book having heard the buzzwords — FPS, WebGL, FCP, LCP, sitemap.xml, IndexedDB, painting — without knowing how they fit together. Now you can trace a single URL from your editor through the build, the supply chain, CI, deploy, DNS, TCP, TLS, the CDN, the server, the parser, the pipeline, the event loop, the GPU, the metrics, the search index and the dashboard. You can explain every hop, draw it, measure it and fix it.

More importantly, you can walk into a design review and say, calmly and correctly:

  • “The route transition janks because the new chunk is parsed on the main thread right when we start the exit animation, and that animation uses height, so it can’t run on the compositor.”
  • “Our LCP is fine on your laptop and 4.1 s at p75 on mobile field data. Here’s the breakdown, and here’s the fix.”
  • “We shouldn’t add that third-party script without a budget, and here’s why.”
  • “Let’s put immutable on hashed assets and revalidate HTML.”

…and then draw it on a whiteboard.

That’s the glue. Most developers build features and leave it to chance. You don’t anymore.

Now go and make something that feels good on Priya’s phone.