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.
- 01Say 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.
- 02Check 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.
- 03Make 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:
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:
// 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
trueandfalseinto yes and no. - Lines 6 to 8 print
client: 2939 bytes, name no, price no, 0 reviewsandserver: 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.
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.
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.
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 it is | What Google's docs say | What that means for ranking |
|---|---|---|
| Relevance: the page answers the search | Google "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 way | They "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 score | Listed 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."
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:
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:
// 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)andTea 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:
- Phone visits in Ravi's field data72
- LCP p75 (good up to 2,500 ms)4,896 ms: poor
- INP p75 (good up to 200 ms)8 ms: good
- CLS p75 (good up to 0.1)0.00: good
- Group status: its worst metricPoor
- Passes the Core Web Vitals?No: LCP is past the good line
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.
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:
- Googlebot fetches the page and reads its raw HTML. It also collects the links in it, to crawl later.
- 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."
- 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.
- 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:
// 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.
chainlists the requests each build waited for, one after another, before all 24 reviews were in the page.reviewsAtis 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 dataandserver: 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:
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:
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.
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.
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 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.
stillloads were left alone.scrolledloads had Asha scroll. - Lines 5 to 7 print
scroll: 0 without a scroll, 24 after one,observer: 24 without a scroll, 24 after oneandhtml: 24 without a scroll, 24 after one.
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:
- First fetch: bytes of HTML2,939
- First fetch: the tea's nameNo
- First fetch: the priceNo
- First fetch: reviews0 of 24
- Chrome, never scrolled: reviews24 of 24
- Chrome, after Asha scrolls: reviews24 of 24
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.
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."
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:
// 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 minuteandkept: 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:
- Pages in one minute, one connection169
- Pages in one hour, one connection10,198
- All 8 of Ravi's tea pages2.8 seconds
- A million pages, one connection98.1 hours
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.
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?
- 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.
Sort each claim by whether Google's docs back it.
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.
Here is Google's rule, run on Ravi's reviews page. What does it print?
// 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`);
}Reviews: doesn't pass (CLS). LCP and INP are good, but the page jumps too much. One metric past its line is enough to fail.
A made-up server takes 500 ms a page. What does the first line print?
// 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`);
}built: 120 pages a minute. Each page takes 500 ms, so 120 fit in a minute. The faster server fits 480.
Which metric decides the status of Ravi's cart page on phones?
INP. The cart's p75 INP is 208 ms, just past the 200 ms line, so the group needs improvement. LCP and CLS are good.
How many bytes of HTML does a crawler's first fetch get for the Reviews on view page?
3,550 bytes. It's the server build without its reviews and their data, so it's much smaller. None of the reviews are in it.
Open lesson 35.1's copy of the client build. In DevTools' Network panel, which request's response holds the tea's price?
mint-tea.json. app.js asks for it, then draws the page from it. That's why a crawler's first fetch has no price.
In Search Console's Crawl Stats report, which chart shows how long your server took to answer Google, on average?
Average response time. It counts every file Google fetched from your site, each one as a separate response.
Check your understanding
For each question, ask: is this about ranking, about passing, or about what Google can read?
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.
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.
Question 3 of 7What do good Core Web Vitals do for a page in Google Search?
Choose an answer to see the explanation.
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.
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.
Question 6 of 7What does this crawl sum print?
Read the code, then predictconst minute = 60 * 1000; const perPage = 250; console.log(`${Math.floor(minute / perPage)} pages`);Choose an answer to see the explanation.
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:
- In-depth guide to how Google Search works, Google Search Central.
- Understanding page experience in Google Search results, Google Search Central.
- The role of page experience in creating helpful content, Google Search Central Blog.
- Understanding Core Web Vitals and Google search results, Google Search Central.
- Overview of CrUX, Chrome for Developers.
- About PageSpeed Insights, Google for Developers.
- Core Web Vitals report, Search Console Help.
- Understand the JavaScript SEO basics, Google Search Central.
- Dynamic rendering as a workaround, Google Search Central.
- Fix lazy-loaded content, Google Search Central.
- URL Inspection tool, Search Console Help.
- Optimize your crawl budget, Google Search Central.
- Reduce the Google crawl rate, Google Search Central.
- Crawl Stats report, Search Console Help.
- IntersectionObserver, MDN.
Coming next: Building a performance culture. Ravi has fixed pages and answered the agency. How does the shop keep its pages fast after this?