completefrontend
Open lab My progress
THE WEB PERFORMANCE FIELD GUIDE

Search and Core Web Vitals

How Google Search uses Core Web Vitals in ranking, what passing does and doesn't do, how crawling and rendering see your page, and myths to drop.

By the end, you can
  • 01
    Say what Google uses from page experienceRead Google's own words on ranking: Core Web Vitals count, relevance comes first, and there's no single signal.
  • 02
    Check whether a page passes, the way Google doesUse the p75 of real visits, Search Console's URL groups and its 28-day check, not a lab score.
  • 03
    Make sure Google can read the page at allCompare raw and rendered HTML, load lazy content without scrolls, and see when server speed limits crawling.

Will a perfect score move us up Google?

The owner of the Leaf and Kettle forwards Ravi an email. It comes from an agency that sells search work. It makes two claims:

  • "Your Lighthouse score must be 100, or Google will bury you."
  • "Your Mint tea page is built with JavaScript. Google can't read it."

The owner asks the question from the end of lesson 41.1: "Is that true? Will a faster page move us up Google?" Ravi doesn't guess. He reads what Google itself says. Then he checks what Google really gets from his pages.

First, how does a page get into Google at all? Google's guide to how Search works names three stages:

  • Crawling: a program called a crawler fetches the page. Google's crawler is called Googlebot.
  • Indexing: Google reads what the page says. It stores that in its index, a huge database.
  • Serving results: someone searches, and Google picks pages from the index and puts them in order. That order is the ranking.

There's one more job inside the crawl. Google renders the page: it runs the page's JavaScript "using a recent version of Chrome". That way it sees what the scripts add. Here is Ravi's client-rendered Mint tea page from lesson 35.1, on its way through:

The client-rendered Mint tea page on its way into Google. 1, crawl: the raw HTML, 2,939 bytes, with the title Mint tea, Leaf and Kettle, the header, an empty main and a script tag for app.js. 2, render: Chrome runs app.js and the whole page appears, photo, name, price and reviews. 3, index, then rank: the index keeps Mint tea, £4.80 for 100 g and 24 reviews; for a search, relevance comes first and Core Web Vitals are one signal of many.1. crawl: fetch the HTML2. render: run app.js3. index, then rankHTMLtitle: Mint tea, Leaf and Kettle<header>…</header><main id="app"></main><script … src="app.js">2,939 bytes, no tea yetThe Mint tea page after app.js ran: the green header, the photo, the name, the size picker and the pricethe index keeps:Mint tea£4.80 for 100 g24 reviewsthen, for a search:relevance first,Core Web Vitals:one signal of many
The client-rendered Mint tea page on its way into Google. Its first fetch is 2,939 bytes with no tea in them. After Chrome runs app.js, the page holds the tea, and Google can index it and rank it.

Look at the first window. It's what a crawler fetches first: the page's raw HTML, exactly as the server sent it, before any JavaScript runs. It has a title and an empty <main>. The tea comes only after Chrome runs app.js. Ravi asked for both of his builds the way a crawler does, with no JavaScript:

What a crawler's first fetch holdsPop out in the code editor (opens in a new tab)JavaScript
// The raw HTML of each build, as a crawler first fetches itconst client = { bytes: 2939, name: false, price: false, reviews: 0 };const server = { bytes: 11277, name: true, price: true, reviews: 24 };const has = (found) => (found ? "yes" : "no"); for (const [build, html] of Object.entries({ client, server })) {  console.log(`${build}: ${html.bytes} bytes, name ${has(html.name)}, price ${has(html.price)}, ${html.reviews} reviews`);}
  • Line 1 is a comment.
  • Lines 2 and 3 are recorded. Each holds one build's raw HTML: its size in bytes, whether the tea's name and price are in it, and how many reviews.
  • Line 4 turns true and false into yes and no.
  • Lines 6 to 8 print client: 2939 bytes, name no, price no, 0 reviews and server: 11277 bytes, name yes, price yes, 24 reviews.

Both builds have the same title: "Mint tea, Leaf and Kettle". But only the server build's HTML holds the tea. So the agency is half right. A program that reads only the raw HTML finds no tea on the client page. Google does more: it renders, later. Why it matters: what's in the raw HTML, every crawler can read at once.

Real-life analogyA library takes in a new book

A library gets a new book. A librarian collects it and reads the cover. Most books come bound, so the librarian can read them at once. Some come as a box of loose pages. Those wait on a shelf until someone has time to put them together. Only then does the book get a catalogue card that lists what's inside.

In real life: Collecting the book and reading its cover
In Google Search: Crawling: fetching the raw HTML
In real life: A book that comes bound, ready to read
In Google Search: A server-rendered page: the content is in the HTML
In real life: A box of loose pages, left on the shelf until someone has time
In Google Search: A client-rendered page, waiting to be rendered
In real life: The catalogue card listing what's inside
In Google Search: The index

So where does speed come in? In two places:

  • In ranking. Google's ranking uses the Core Web Vitals: three numbers measured on real visits.
  • Before ranking. How fast the server answers decides how much Google can crawl. Whether the content needs JavaScript decides when Google can read it.
The main idea

Google ranks a page first for how well it answers the search. Core Web Vitals from real visits are one signal among many. Passing them doesn't put a page at the top. Speed also matters before ranking. Google can only rank what it can crawl and render, so make sure your content is there to read.

How the course recorded it

  • The pages: lesson 35.1's client and server builds of the Mint tea page, at £4.80 for 100 g, with 24 reviews. Two more versions load the reviews later, in two different ways.
  • The server: the course's own computer. Every answer waited 100 ms, one round trip, as in lesson 14.2. Building a page, or the tea's data, took 250 ms more, as in lesson 35.1.
  • The crawler: a small Node.js script asked for each page's raw HTML, with no JavaScript, 5 times.
  • The browser: Chrome 157 loaded each page 5 times, with an empty cache each time, in a phone-sized window, 500 by 823 px. Each number is from the middle load.

How page experience counts in ranking

The agency says Google ranks by speed. Google's own page on this is called "Understanding page experience in Google Search results". Page experience is what it's like to use a page: how fast it loads and answers, whether it's safe, and whether it works on a phone.

The page opens with this: "Google's core ranking systems look to reward content that provides a good page experience." Then it lists questions to ask about your own pages. Do they have good Core Web Vitals? Are they served over HTTPS? Do they work on phones? Do they avoid too many ads, and pop-ups that cover the content? Is the main content easy to find?

So speed is one part of a longer list. Which parts count in ranking? Google's answers are short:

  • Is there one page experience signal? "There is no single signal." The ranking systems look at many.
  • Which parts are used? "Core Web Vitals are used by our ranking systems." The other parts "don't directly help your website rank higher". But they make a site "more satisfying to use", and that fits what ranking rewards.
  • How much does it matter? "Google Search always seeks to show the most relevant content, even if the page experience is sub-par."

That last answer goes on. For many searches, "there is lots of helpful content available". In such cases, a great page experience "can contribute to success in Search". A page is relevant when it answers what someone searched for. That comes first.

Real-life analogyA restaurant guide lists the food first

You ask a restaurant guide for the best vegetable curry nearby. It lists places that serve a good one. Among ten good curry places, a clean and comfortable room can lift one above another. But no spotless room gets a burger bar onto your curry list.

In real life: Serving the dish you asked for
In Google Search: Relevance: the page answers the search
In real life: A clean, comfortable room
In Google Search: A good page experience, with good Core Web Vitals
In real life: Comfort tipping the order among good curry places
In Google Search: Page experience helping when many pages answer well
In real life: A spotless burger bar in a list of curry places
In Google Search: A fast page that doesn't answer the search

Google's search blog adds one more fact. People often speak of a "page experience update". The blog says it "was not a separate ranking system". It also "did not combine all these signals into one single 'page experience' signal." So there's no one score to max out.

Google also judges pages one at a time, mostly. Its ranking systems "generally evaluate content on a page-specific basis", though there are "some site-wide assessments". Read this table across: each thing, what Google's docs say, and what it means for ranking.

What Google's docs say counts
What it isWhat Google's docs sayWhat that means for ranking
Relevance: the page answers the searchGoogle "always seeks to show the most relevant content, even if the page experience is sub-par."It comes first.
Core Web Vitals: LCP, INP and CLS"Core Web Vitals are used by our ranking systems."It counts, as one signal among many.
HTTPS, a page that works on phones, few ads, no pop-ups in the wayThey "don't directly help your website rank higher", but they fit what ranking rewards.It doesn't lift ranking directly. It's still worth doing for visitors.
A Lighthouse scoreListed as a tool to "identify a range of improvements".It isn't one of the Core Web Vitals. Those are measured on real visits.

Why it matters: a faster page can help, but it can't replace a page that answers the search well. And Google warns that chasing a perfect score "just for SEO reasons may not be the best use of your time." SEO, search engine optimization, is work done to rank better in search.

What passing the Core Web Vitals means

The agency wants a Lighthouse 100. Google's ranking uses the Core Web Vitals. Are those the same thing? No. The Core Web Vitals are three numbers, from lesson 3.1:

  • LCP, Largest Contentful Paint: when the biggest image or text appears. Good is 2.5 seconds or less.
  • INP, Interaction to Next Paint: how fast the page answers a tap, click or key. Good is 200 ms or less.
  • CLS, Cumulative Layout Shift: how much the page jumps. Good is 0.1 or less.

Google says they "measure real-world user experience". The numbers come from CrUX, the Chrome User Experience Report from lesson 10.1. It holds page loads from real Chrome users who agreed to share them. Chrome's CrUX docs say its data "is used by Google Search to inform the page experience ranking factor."

A Lighthouse score is something else. It's one number from 0 to 100 that sums up one lab load, on one test setup. It isn't one of the Core Web Vitals. Lesson 8.2 ran Lighthouse ten times on one store, changing nothing. It got seven 90s and three 89s. PageSpeed Insights' own docs warn that "having good lab data does not necessarily mean real-user experiences will also be good."

Real-life analogyA bus company's on-time record

A city judges its bus company by its record. It counts every trip of the last four weeks, in rain and in rush hour. A test drive on an empty Sunday road can't change that record. And when the company fixes its timetable, the record improves only as new trips replace old ones.

In real life: Every bus trip of the last four weeks
In Google Search: CrUX: real Chrome visits from the last 28 days
In real life: "3 in 4 buses within 5 minutes of the timetable"
In Google Search: The p75 under Google's good line
In real life: A test drive on an empty Sunday road
In Google Search: A Lighthouse run: one load in a lab
In real life: A new timetable showing up in the record weeks later
In Google Search: A fix showing up in Search Console after 28 days

The rule for passing

PageSpeed Insights spells out what passing means. A page or a site passes the Core Web Vitals assessment "if the 75th percentiles of all three metrics are Good." The 75th percentile, or p75, is the visit three quarters of the way up the line: three visits in four were at or under it. If there isn't enough INP data, LCP and CLS alone decide.

Ravi already has field data: the RUM from his audit in lesson 40.1, before his fixes. RUM, real user monitoring, means his pages send home their numbers from every real visit. Here is his home page on phones, one tick for each visit:

72 phone visits to Ravi's home page, each drawn as a tick at its LCP, from 0.7 s to 17.9 s. The good line is at 2.5 s. The p75 is 4.9 s, past the line.good line, 2.5 sp75, 4.9 s0 s4 s8 s12 sand one at 17.9 s72 phone visits, one tick each, at its LCP
Ravi's field data from his audit in lesson 40.1: each of the 72 ticks is one phone visit's LCP on the home page. Three visits in four came at or under 4.9 s, the p75, which is past the 2.5 s line.

29 of the 72 visits got the photo within 2.5 seconds. But the p75 was 4.9 seconds, far past the line. So before the fix, the home page didn't pass. Here is Google's rule, run on three of Ravi's pages:

Does each page pass?Pop out in the code editor (opens in a new tab)JavaScript
// p75 on phones, from Ravi's audit (lesson 40.1)const groups = {  "Mint tea": { LCP: 592, INP: 56, CLS: 0 },  Home: { LCP: 4896, INP: 8, CLS: 0 },  "Tea list": { LCP: 664, INP: 376, CLS: 0 },};const good = { LCP: 2500, INP: 200, CLS: 0.1 }; for (const [page, p75] of Object.entries(groups)) {  const over = Object.keys(good).filter((metric) => p75[metric] > good[metric]);  console.log(over.length ? `${page}: doesn't pass (${over.join(", ")})` : `${page}: passes`);}
  • Line 1 is a comment. These are p75s on phones.
  • Lines 3 to 5 hold three pages' p75s: LCP and INP in ms, and CLS.
  • Line 7 holds Google's line for good on each metric.
  • Line 10 keeps the metrics that are past their line.
  • Line 11 prints Mint tea: passes, Home: doesn't pass (LCP) and Tea list: doesn't pass (INP).

The Mint tea page passed on phones. The home page didn't: its photo came too late, which lesson 40.3's fix went after. The tea list answered taps too slowly. Why it matters: one page can pass while the next one fails, so check each kind of page, not just the home page.

Search Console groups similar pages

Ravi's numbers come from his own RUM. Google's Search Console, its tool for site owners, has a Core Web Vitals report. It's built from CrUX instead. Its help page explains how it works:

  • It puts pages "that have a similar user experience" into URL groups, and shows one status for each group.
  • A group's number is its p75 "in the last 28 days".
  • A group's status is its worst metric. Poor CLS with good INP makes the group "poor".
  • When you think you've fixed an issue, you click Start Tracking. That begins "a 28-day monitoring session". It "does not trigger re-indexing".

Why it matters: a fix shows up only as new visits replace old ones. Expect weeks, not a day. Try the rule on five of Ravi's pages:

Playground: does this group pass?
Home, phones
  1. Phone visits in Ravi's field data72
  2. LCP p75 (good up to 2,500 ms)4,896 ms: poor
  3. INP p75 (good up to 200 ms)8 ms: good
  4. CLS p75 (good up to 0.1)0.00: good
  5. Group status: its worst metricPoor
  6. Passes the Core Web Vitals?No: LCP is past the good line
Try it yourself
Home on phones: doesn't pass

Each row compares one p75 with Google's line for good. The group's status in Search Console is its worst metric. It passes only when all three are good.

Ravi's field data from his audit in lesson 40.1, before his fixes: real loads of his pages on phones, measured by his own RUM. Search Console reads CrUX instead, with the same lines.

What Google reads before and after JavaScript

Now the agency's second claim: "Google can't read pages built with JavaScript." Google's JavaScript SEO guide says otherwise. Search runs JavaScript "with an evergreen version of Chromium": the engine inside Chrome, kept up to date.

But it happens in steps, and the steps take turns. The guide describes them:

  1. Googlebot fetches the page and reads its raw HTML. It also collects the links in it, to crawl later.
  2. It puts each page that answered with a 200 status into a render queue, a waiting line, unless the page asks not to be indexed. A page "may stay on this queue for a few seconds, but it can take longer than that."
  3. When Google's resources allow, "a headless Chromium renders the page and executes the JavaScript." Headless means a browser with no window on a screen.
  4. Google indexes the rendered page.

That's the library's box of loose pages. It waits on the shelf until someone has time. A server-rendered page doesn't wait for its content: the tea is in the first fetch. The guide agrees. Server rendering "is still a great idea because it makes your website faster for users and crawlers, and not all bots can run JavaScript."

How much work is the render itself? Chrome loaded both of Ravi's builds:

When the reviews were in the pagePop out in the code editor (opens in a new tab)JavaScript
// Chrome loading each build: the middle of 5 loads, times in msconst client = { chain: ["the HTML", "app.js", "the tea's data"], reviewsAt: 573 };const server = { chain: ["the HTML"], reviewsAt: 363.4 }; for (const [build, load] of Object.entries({ client, server })) {  console.log(`${build}: reviews in the page at ${load.reviewsAt} ms, after ${load.chain.join(", then ")}`);}
  • Line 1 is a comment. These are the middle loads.
  • Lines 2 and 3 are recorded. chain lists the requests each build waited for, one after another, before all 24 reviews were in the page. reviewsAt is when they were.
  • Lines 5 to 7 print client: reviews in the page at 573 ms, after the HTML, then app.js, then the tea's data and server: reviews in the page at 363.4 ms, after the HTML.

The client build needed two more trips after the HTML: app.js, then the tea's data. Each one waited for the one before. Even with Chrome at full speed, its reviews came 210 ms after the server build's. Here are both builds, with JavaScript off and on:

Ravi's Mint tea page in Chrome, in a 500 by 823 window. Client rendering with JavaScript off: only the green header. With JavaScript on: the whole page, reviews in at 573 ms. Server rendering with JavaScript off: the whole page. With JavaScript on: the whole page, reviews in at 363.4 ms.client renderingserver renderingThe Mint tea page, JavaScript off: only the green header, nothing elseJavaScript offonly the headerThe Mint tea page, JavaScript on: the whole page: photo, name, price and reviewsJavaScript onreviews at 573 msThe Mint tea page, JavaScript off: the whole page: photo, name, price and reviewsJavaScript offthe whole pageThe Mint tea page, JavaScript on: the whole page: photo, name, price and reviewsJavaScript onreviews at 363.4 ms
Real frames from Chrome. With JavaScript off, the client build shows only its header, and the server build shows the whole page. With JavaScript on, the two look the same.

With JavaScript off, the client page is only a green header. Google gets the tea after its render queue. Other crawlers may never get it: Google's page on dynamic rendering says other search engines "may choose to ignore JavaScript". Why it matters: put the content you want found in the HTML. Server rendering or static pages, from lesson 35.1, do that.

Reviews that wait for a scroll

Ravi's reviews are long. A friend suggests loading them only when the visitor gets near them. That's lazy loading: fetching something only when it's about to be needed. Lesson 18.3 lazy-loaded images. Here are two ways to do it for the reviews. Both start from the server build, with an empty list. The first waits for a scroll:

Reviews that load on a scrollJavaScript
const list = document.querySelector(".reviews");let asked = false;addEventListener("scroll", async () => {  if (asked || list.getBoundingClientRect().top > innerHeight) return;  asked = true;  const reviews = await fetch("reviews.json").then((response) => response.json());  list.innerHTML = reviews.map(review).join("");});
  • Line 1 finds the empty reviews list.
  • Line 2 remembers whether the reviews were asked for yet.
  • Line 3 runs a function every time the page scrolls.
  • Line 4 stops if they were asked for, or if the list is still below the window.
  • Lines 5 to 7 fetch the reviews and draw them with lesson 35.1's review().

The second uses an IntersectionObserver: a browser object that tells you when an element comes into view, as lesson 18.3 showed.

Reviews that load when they come into viewJavaScript
const list = document.querySelector(".reviews");const watcher = new IntersectionObserver(async ([entry]) => {  if (!entry.isIntersecting) return;  watcher.disconnect();  const reviews = await fetch("reviews.json").then((response) => response.json());  list.innerHTML = reviews.map(review).join("");});watcher.observe(list);
  • Line 2 makes the observer. Its function runs once at the start, then whenever the list moves into or out of view.
  • Line 3 stops if the list isn't in view.
  • Line 4 stops watching, so the reviews load only once.
  • Lines 5 and 6 fetch the reviews and draw them, like the first script.
  • Line 8 starts watching the list.
Real-life analogyLights on a switch, and lights on a sensor

A gallery has two rooms. In one, the lights come on when you press a switch. In the other, a sensor turns them on when anyone is in the room. A visitor who never touches anything sees only the second room's paintings.

In real life: A light that waits for someone to press the switch
In Google Search: Reviews that wait for a scroll event
In real life: A light on a sensor that sees anyone in the room
In Google Search: Reviews that load when the list is in view
In real life: A visitor who never touches anything
In Google Search: Google's renderer, which doesn't scroll or click

Google's guide on lazy-loaded content explains why that matters. It asks for content that loads "whenever it is visible in the viewport": the part of the page on screen. It names the browser's own lazy loading and IntersectionObserver. Those "don't rely on user actions, such as scrolling or clicking". That's "important as Google Search does not interact with your page."

The course loaded both pages, and the server build with its reviews in the HTML. Each load was left alone for 3 seconds, or had Asha scroll down 400 px with the mouse wheel:

Reviews in the page, with and without a scrollPop out in the code editor (opens in a new tab)JavaScript
// Reviews in the page at the end of each load, out of 24const still = { scroll: 0, observer: 24, html: 24 };const scrolled = { scroll: 24, observer: 24, html: 24 }; for (const page of Object.keys(still)) {  console.log(`${page}: ${still[page]} without a scroll, ${scrolled[page]} after one`);}
  • Line 1 is a comment.
  • Lines 2 and 3 are recorded: how many reviews were in the page at the end of each load. still loads were left alone. scrolled loads had Asha scroll.
  • Lines 5 to 7 print scroll: 0 without a scroll, 24 after one, observer: 24 without a scroll, 24 after one and html: 24 without a scroll, 24 after one.
Three versions of the Mint tea page, loaded in a 500 by 823 window and never scrolled. Reviews on scroll: 0 reviews in the page. Reviews on view: 24 reviews in the page. Reviews in HTML: 24 reviews in the page.reviews on scrollThe Mint tea page with reviews on scroll, never scrolled: the Reviews heading with nothing under it0 reviewswaits for a scrollreviews on viewThe Mint tea page with reviews on view, never scrolled: the first review under the Reviews heading24 reviewsloads when in viewreviews in HTMLThe Mint tea page with reviews in HTML, never scrolled: the first review under the Reviews heading24 reviewssent with the page
Real frames from Chrome, 823 px tall, after 3 seconds with no scroll. The reviews list started inside the window. The observer loaded it; the scroll listener never ran.

The empty list's top sat 644 px down the page, inside the 823 px window. So the observer saw it at once and loaded the reviews with no scroll. The scroll listener never ran. For Asha, both pages worked. Her scroll started at 1,509 ms, and the reviews were in at 1,927 ms. That's how this bug hides: everyone who tries the page by hand scrolls it.

Why it matters: text that people should find in Search belongs in the HTML. If you lazy-load, load on view, not on a scroll. Then check what Google got. Search Console's URL Inspection tool shows the page's rendered HTML, so you can look for your content there. Pick a page to see what each reader gets:

Playground: what each reader gets
Client rendering
  1. First fetch: bytes of HTML2,939
  2. First fetch: the tea's nameNo
  3. First fetch: the priceNo
  4. First fetch: reviews0 of 24
  5. Chrome, never scrolled: reviews24 of 24
  6. Chrome, after Asha scrolls: reviews24 of 24
Try it yourself
Client rendering: 0 of 24 reviews in the raw HTML, 24 of 24 after a render with no scroll

The first fetch is the raw HTML, with no JavaScript, as a crawler first gets it. The two Chrome rows run the page's JavaScript in a phone-sized window: once left alone, once with Asha's scroll.

Ravi's Mint tea page four ways, recorded in Chrome. Each number is the middle of five loads.

A faster server gets more pages crawled

The last place speed counts is the crawl itself. Google can't fetch every page on the web as often as it likes. It also doesn't want to overload anyone's server. So each site gets a crawl budget: "the set of URLs that Google can and wants to crawl". Google's guide splits it in two:

  • Crawl capacity limit: how hard Google may crawl. It "limits the total amount of time your server spends holding connections open for Google".
  • Crawl demand: how much Google wants to crawl. That depends on the site's size, how often it changes, its quality, and how relevant it is, compared with other sites.

Server speed moves the first one. If response times "remain stable or improve, the limit goes up". If the site slows down or answers with errors, "the limit goes down and Google crawls less."

Real-life analogyA delivery driver's shift

A driver has an eight-hour shift. If each stop takes ten minutes, he makes 48 stops. If each takes half an hour, he makes 16. And if one street keeps him waiting, the depot sends him there less often.

In real life: The hours in the driver's shift
In Google Search: The time Google keeps connections open to your server
In real life: How long each stop takes
In Google Search: How long your server takes to answer one page
In real life: Stops made in a shift
In Google Search: Pages crawled
In real life: The depot sending him less often to a street that keeps him waiting
In Google Search: Google lowering the limit when your server slows down

Here's the sum. The course timed two of Ravi's servers on one kept-open connection, one page after another, with the same 100 ms round trip. The first builds the page for each visit. The second keeps a built copy ready, like lesson 35.1's static build:

Pages in a minute of connection timePop out in the code editor (opens in a new tab)JavaScript
// Time per page on one kept-open connection, in ms (the middle of 10)const perPage = { built: 353.1, kept: 102.1 };const minute = 60 * 1000; for (const [server, ms] of Object.entries(perPage)) {  console.log(`${server}: ${Math.floor(minute / ms)} pages a minute`);}
  • Line 1 is a comment. Each time is the middle of 10 fetches, from the request to the last byte.
  • Line 2 is recorded: the time per page for each server.
  • Line 3 is one minute in ms.
  • Line 6 divides the minute by the time per page. It prints built: 169 pages a minute and kept: 587 pages a minute.

In the same connection time, the kept copy fits 3.5 times as many pages. Google's guide gives the same advice: "If Google can load and render your pages faster, we might be able to read more content from your site." Try other times per page:

Playground: time per page, and pages crawled
353 ms a page
  1. Pages in one minute, one connection169
  2. Pages in one hour, one connection10,198
  3. All 8 of Ravi's tea pages2.8 seconds
  4. A million pages, one connection98.1 hours
Try it yourself
353 ms a page: 169 pages a minute

Each row divides a stretch of connection time by the time per page. The course recorded 353.1 ms for a page built for each visit, and 102.1 ms for a kept copy.

The sums count one connection asking for one page after another. Google can open more connections, and its limit moves with your server's speed.

Who needs to care

Google's guide opens by saying who it's for. It names sites with "1 million+ unique pages" that change about once a week, or "10,000+ unique pages" that change every day. Other sites can skip it. If your pages "seem to be crawled the same day that they are published, you don't need to read this guide."

Ravi has 8 teas. At 353.1 ms a page, all 8 pages fit in 2.8 seconds of one connection. Crawl budget isn't his problem.

Errors still matter, even for him. A 500 or 503 status means the server failed, and 429 means "too many requests". When many requests get one of these, Google slows its crawl of the whole site. Its page on reducing the crawl rate warns about this. Then "existing pages will be refreshed less frequently (for example, prices and product availability may take longer to be reflected in Search)". Ravi's new £4.80 price would take longer to show. Why it matters: a small site doesn't need to tune its crawl budget, but it does need a server that answers without errors.

Myth or Google's own words?

The agency's email is full of claims like these. Sort each one: does Google's own documentation say it, or is it a myth?

Myth or Google's own words?
  • Core Web Vitals are used by Google's ranking systems.
  • You need a Lighthouse score of 100 to rank.
  • Good Core Web Vitals guarantee a top place.
  • Google runs a page's JavaScript with an up-to-date Chromium.
  • Google scrolls the page to load lazy content.
  • There's one single page experience signal.
  • Search Console's report reads 28 days of real visits.
  • A faster server can let Google crawl more of a big site.
  • A shop with eight tea pages must manage its crawl budget.
  • Google judges page experience mostly one page at a time.
Try it yourself
0 of 10 correct

Sort each claim by whether Google's docs back it.

Choose a category for every card. You can change an answer at any time; Reset clears them all.

Ravi's answer to the owner fits in three lines. A Lighthouse 100 isn't what Google measures: it reads real visits. His own field data shows which pages to fix, like the home page's photo in lesson 40.3. And the reviews go in the HTML, so every crawler can read them.

Common mix-ups

  • "You need a Lighthouse score of 100 to rank." No. The Core Web Vitals that Google's ranking uses come from real visits, through CrUX. A Lighthouse score sums up one lab load. Google says chasing a perfect score just for SEO "may not be the best use of your time."
  • "Passing the Core Web Vitals puts a page at the top." No. Google says good results don't guarantee a top ranking. Relevance comes first.
  • "There's one page experience score." No. "There is no single signal." The "page experience update" was never a separate ranking system.
  • "Only Core Web Vitals matter for page experience." No. Google asks about HTTPS, phones, ads and pop-ups too. They don't lift ranking directly, but they fit what ranking rewards.
  • "Google can't read JavaScript pages." No. Google renders them with an evergreen Chromium, after a queue. Other bots may not run JavaScript at all.
  • "Google scrolls to load lazy content." No. Google Search "does not interact with your page". Content that waits for a scroll stays out of what it reads.
  • "Every site must manage its crawl budget." No. Google's guide is for very large sites, or big sites that change daily.
  • "A fix shows in Search Console the next day." No. Its numbers cover 28 days of visits, and its check watches for 28 days.

Practice exercises

Answer first, then use the hints.

Exercise 1 · Warm-upThe reviews page

Here is Google's rule, run on Ravi's reviews page. What does it print?

Starter codePop out in the code editor (opens in a new tab)JavaScript
// p75 on phones for Ravi's reviews page (lesson 40.1)
const groups = {
  Reviews: { LCP: 1632, INP: 48, CLS: 0.26 },
};
const good = { LCP: 2500, INP: 200, CLS: 0.1 };

for (const [page, p75] of Object.entries(groups)) {
  const over = Object.keys(good).filter((metric) => p75[metric] > good[metric]);
  console.log(over.length ? `${page}: doesn't pass (${over.join(", ")})` : `${page}: passes`);
}

Answer, then press Check. Spacing and letter case don’t matter.

    Exercise 2 · Warm-upA slower server

    A made-up server takes 500 ms a page. What does the first line print?

    Starter codePop out in the code editor (opens in a new tab)JavaScript
    // A made-up slower server, in ms per page
    const perPage = { built: 500, kept: 125 };
    const minute = 60 * 1000;
    
    for (const [server, ms] of Object.entries(perPage)) {
      console.log(`${server}: ${Math.floor(minute / ms)} pages a minute`);
    }

    Answer, then press Check. Spacing and letter case don’t matter.

      Exercise 3 · PracticeThe cart's status

      Which metric decides the status of Ravi's cart page on phones?

      Answer, then press Check. Spacing and letter case don’t matter.

        Exercise 4 · PracticeThe observer page's HTML

        How many bytes of HTML does a crawler's first fetch get for the Reviews on view page?

        Answer, then press Check. Spacing and letter case don’t matter.

          Exercise 5 · ChallengeWhere the price comes from

          Open lesson 35.1's copy of the client build. In DevTools' Network panel, which request's response holds the tea's price?

          Answer, then press Check. Spacing and letter case don’t matter.

            Exercise 6 · ChallengeSpeed in the crawl report

            In Search Console's Crawl Stats report, which chart shows how long your server took to answer Google, on average?

            Answer, then press Check. Spacing and letter case don’t matter.

              Check your understanding

              For each question, ask: is this about ranking, about passing, or about what Google can read?

              The search and Core Web Vitals quiz · 7 questionsScore: first tries count
              1. Question 1 of 7The agency says Google ranks pages by their Lighthouse score. Where does Google Search's Core Web Vitals data come from?

                Choose an answer to see the explanation.

              2. Question 2 of 7A group of pages has a p75 LCP of 2.1 s, INP of 150 ms and CLS of 0.18. What status does Search Console give the group?

                Choose an answer to see the explanation.

              3. Question 3 of 7What do good Core Web Vitals do for a page in Google Search?

                Choose an answer to see the explanation.

              4. Question 4 of 7Google's crawler fetches the client-rendered Mint tea page. What does that first fetch hold?

                Choose an answer to see the explanation.

              5. Question 5 of 7Ravi's reviews load on the visitor's first scroll. What will Google's rendered page hold?

                Choose an answer to see the explanation.

              6. Question 6 of 7What does this crawl sum print?

                Read the code, then predictPop out in the code editor (opens in a new tab)JavaScript
                const minute = 60 * 1000;
                const perPage = 250;
                console.log(`${Math.floor(minute / perPage)} pages`);

                Choose an answer to see the explanation.

              7. Question 7 of 7Which sites does Google's crawl budget guide say it is for?

                Choose an answer to see the explanation.

              Key takeaways

              • Google ranks for relevance first. Core Web Vitals are one signal among many, and passing doesn't guarantee the top.
              • There's no single page experience signal. HTTPS, phones, ads and pop-ups don't lift ranking directly.
              • Search's Core Web Vitals come from CrUX, real Chrome visits, not from a Lighthouse score.
              • A page passes when the p75 of LCP, INP and CLS are all good. Search Console groups similar pages, and its check takes 28 days.
              • Google renders JavaScript after a queue, and never scrolls or clicks. Put content you want found in the HTML.
              • A faster server lets Google crawl more of a very large site. Small sites don't need to manage crawl budget.

              Remember the one-liner.
              Rank with relevance, pass with real visits, and make sure Google can read what you want found.

              Sources

              The facts on this page come from these docs:

              Coming next: Building a performance culture. Ravi has fixed pages and answered the agency. How does the shop keep its pages fast after this?

              CompleteFrontend Clear concepts. Working examples.