open atlas
↑ Back to track
Browser & Frontend Runtime WEB · 08 · 01

The full picture: URL to LCP to INP as a relay race

A page load is a relay race across network, parse, paint, and hydration stages — one slow runner makes every later runner late, and the user only sees the finish line.

WEB Junior ◷ 10 min
Level
FoundationsJuniorMiddleSenior
Already know this unit? Take a 1-minute quick check →

Bea taps a product link. The page paints the photo and price after 1.4 seconds — it looks done. She taps “Add to cart” at 2 seconds and nothing happens. The button is not broken; it is not wired up yet. Hydration has not finished. By the end of this lesson you will know exactly which stage of a page load creates that gap — and why fixing the wrong runner changes nothing.

The relay-race metaphor.

When you look at a slow page, which runner do you blame? Before you can answer that, you need to know who the runners are and in what order they pass the baton.

Think of a page load as a relay race with four runners, each passing a baton to the next:

  1. Network — fetches the HTML bytes from the server.
  2. Parse — builds the DOM from HTML and the CSSOM from CSS.
  3. Paint — lays out the page and draws the first frame. At this point the page looks done.
  4. Hydrate — downloads and runs the JavaScript that attaches event handlers and state to the painted page. Only now does the page work.

The race is only as fast as the whole chain. If any runner stumbles, every runner after them is late. The user only sees the finish line — when the page looks done and when it actually responds to a tap. Together these four stages mean that “the page is slow” could be a network problem, a CSS problem, a JavaScript size problem, or a hydration problem — and without the relay frame, you are guessing.

Why care.

Almost no real performance problem lives in one place. A slow page is usually a chain problem: the server was a little slow, the bundle was a little big, the hero image was a little late — and together they push the page over the line into “slow.” Tracing the whole chain beats guessing at one step.

A real relay trace (mid-range phone, 4G)
Page looks done (LCP)
1.4 s
Page becomes interactive (hydration done)
3.0 s
Gap: looks done but is not
1.6 s
Good LCP threshold
≤ 2.5 s
Good INP threshold
≤ 200 ms
Order the steps

Trace a page from the user pressing Enter to a working button. Drag the stages into order.

  1. 1 Network: fetch the HTML bytes from the server
  2. 2 Parse: build the DOM from HTML, the CSSOM from CSS
  3. 3 Paint: lay out and draw the first frame — page looks done
  4. 4 Hydrate: run the JavaScript, wire up the buttons
  5. 5 Interact: a tap now gets a response
Quiz

A page 'looks done' but a button does not work yet. Which stage of the relay is still running?

Quiz

Why is a slow page usually a 'chain problem'?

Complete the analogy

In the relay-race metaphor, the page 'looks done' when the picture is painted, but it is not truly done until one more runner finishes — the one who wires up the buttons. What is that final runner's job called?

Compute it

In the read-aloud trace, the page looks done at 1.4 s but is only interactive at 3.0 s. How many seconds is the 'looks done but is not' gap?

seconds
Why this works

The gap between “painted” and “interactive” has a name in the performance literature: the hydration uncanny valley. The page looks alive — text, images, buttons all visible — but it is not, because the JavaScript has not finished hydrating. It is “uncanny” because appearances deceive. A good LCP (fast paint) with a poor INP (slow first interaction) is the measurable signature of a page stuck in this valley.

Recall before you leave
  1. 01
    What are the four relay runners of a page load, in order?
  2. 02
    Why is 'looks done' not the same as 'works'?
  3. 03
    What makes a slow page a 'chain problem'?
Recap

A page load is a relay race across four stages: network, parse, paint, and hydrate. The race is only as fast as the whole chain — one slow runner delays every runner after. The user sees two moments: when the page looks done (after paint, LCP territory) and when it actually works (after hydration, INP territory). The gap between them — up to 1.6 seconds in the trace above — is where taps are dropped and users feel the site is broken. Most real performance problems are chain problems, not single-step failures, which is why tracing the whole chain beats guessing at one place. Now when you see a button that does not respond on a painted page, you know to look at the hydration runner — not the button.

Practice

Start at the top. Tasks go easiest → hardest: recall a fact, apply it to a case, then a senior-level stretch. Open one, attempt it, then reveal.

recallapplystretch0 of 6 done
Connected lessons
appears again in296

Something unclear?

Ask a question about this lesson. Questions are anonymous and go straight to the author to make the lesson better.

shortcuts expand
search
K
prev piece
k
next piece
j
cycle tier
t
this menu
?
sources3
expand
  1. 01
  2. 02
  3. 03

Trademarks belong to their respective owners. Editorial reference only.