Most owners meet PageSpeed Insights the same way. A cold email lands with a screenshot of a red 38 and an offer to fix it, or a relative who "does websites" runs it on a laptop at a birthday party. The number looks like a school grade, so it gets treated like one. It isn't. It's the outcome of one simulated page load on one emulated phone, and Google's own documentation expects it to drift from run to run.

The report is really two tests stacked on top of each other. The upper half shows what real visitors went through over the last four weeks. The lower half is a lab experiment Google ran a few seconds ago, on your behalf, under fixed conditions. They answer different questions, they frequently disagree, and knowing which half you're looking at clears up most of the confusion before it starts.

What follows walks through the free tool most people mean when they say "website speed test", from the box where you paste your address down to the list of suggestions at the bottom. None of it requires writing code.

How to run PageSpeed Insights on your own site

The tool lives at pagespeed.web.dev. It's free, it needs no login, and it will test any public page. A few habits make the result worth reading:

  1. Test the page customers actually land on. If your Google Ads point at a water heater page, or most search visits arrive on a service-area page, paste that address in. Every URL gets its own report, and the homepage isn't always the page with the problem.
  2. Start on the Mobile tab. Google's documentation says the mobile run emulates a mid-tier phone on a mobile network, while the desktop run emulates a computer on a wired connection. The desktop number nearly always looks kinder, which makes it comforting and not very informative.
  3. Run it three times and note the spread. Conditions shift between runs, and Google's Lighthouse documentation suggests treating performance as a distribution of scores rather than one figure. If you get 71, then 78, then 74, your page is "mid-70s", not 78.
  4. Check whether the top section is showing "This URL" or "Origin". When a single page doesn't have enough real-visitor data, the tool falls back to data for your whole domain. That's still worth reading, but it describes the site as a whole, not the page you typed in.
  5. Or run the same lab test from your own computer. Chrome ships it built in: open the page in an Incognito window, open DevTools, and pick the Lighthouse panel. Incognito matters because extensions inject their own code, and Google lists browser extensions among the things that throw scores off.

Whichever site speed test you end up using, write down the date, the page and the device setting next to every result. A score with no context is just a number someone can wave at you later.

Field data and lab data: the two halves of the report

The block at the top is field data. It comes from the Chrome User Experience Report, shortened to CrUX, which gathers timing data from real Chrome users who have opted in to sharing usage statistics. PageSpeed Insights shows what those visitors experienced over the previous 28 days.

Each field number is reported at the 75th percentile. Picture every visit from the past 28 days, sorted from fastest to slowest, and read the value three quarters of the way down the list. If LCP shows 2.3 seconds, three out of every four visits saw the main content appear within 2.3 seconds, and the slowest quarter waited longer. Choosing that point means a page can't pass on the strength of its typical visit while a sizeable slice of people sit waiting.

The block underneath is lab data. Lighthouse, the engine inside PageSpeed Insights, loads your page once on an emulated device with a fixed network setting, from a single location, typically with an empty cache. Every variable is pinned down. That's what makes it good for diagnosis and poor as a picture of what your customers see.

Field data (top)Lab data (bottom)
SourceReal Chrome visits to your page or domainOne simulated load run by Lighthouse
Time coveredThe previous 28 daysThe moment you ran the test
Taps and clicksMeasures real interactionsCan't interact; uses Total Blocking Time as a stand-in
Good forKnowing whether you have a problemWorking out why
Can be emptyYes, on low-traffic pagesNo

When the two disagree, Google's guidance on web.dev is plain about it: let the field data set your priorities. A page that scores 52 in the lab while passing in the field is doing fine for the people who actually visit. A page that scores 95 in the lab and fails in the field has a problem the lab didn't reproduce, quite possibly something that only appears once a real person starts scrolling and tapping.

Why the top half might be blank

Lots of small business sites get a message saying there isn't enough real-user data. That isn't a penalty and nothing is broken. CrUX only includes pages that are publicly discoverable and that clear a minimum number of visitors. A newer site, or a service page that gets a handful of visits a week, may not clear it for individual pages, and sometimes not for the domain either.

When that happens, the lab section is all you have. Use it for what it does well, pointing at causes, and don't read its score as a verdict.

Who the field data leaves out

CrUX collects from Chrome on desktop and on Android. Google's methodology page excludes Chrome on iOS, and Safari isn't Chrome at all, so people visiting from an iPhone aren't in it. If most of your customers book from iPhones, the field numbers describe everyone else. That doesn't make them wrong, but it's one more reason to read them as a sample rather than a headcount.

Core Web Vitals, in plain English

Of everything in the field block, three measurements carry the weight. Google calls them Core Web Vitals, and each one describes something a visitor feels rather than something an engineer cares about for its own sake.

Largest Contentful Paint (LCP): when the main thing shows up

The time from the visitor following your link to the largest piece of content in view finishing its render. On a typical small business site that's the hero photo or the big headline beside it. Google's LCP guide says the resource behind it, when there is one, is either an image or a web font. If someone is staring at an empty grey rectangle where your finished patio photo is supposed to be, that wait is LCP.

Interaction to Next Paint (INP): whether the page answers back

How long the page takes to show a visible response after someone taps, clicks or types. You've met a slow one: you tap the menu icon and nothing happens for a beat, so you tap again and it opens and closes. Or you tap "Call now" and the screen hangs because a chat widget is still loading in the background.

Cumulative Layout Shift (CLS): whether things stay put

A measure of how much the layout jumps around as the page loads. It isn't in seconds; it's a plain number where 0 means nothing moved. A bad one is familiar too: your thumb is heading for "Get a quote", a banner loads above it, the button slides down, and you land on something else.

MetricGoodNeeds improvementPoor
LCP2.5 s or less2.5 to 4 sover 4 s
INP200 ms or less200 to 500 msover 500 ms
CLS0.1 or less0.1 to 0.25over 0.25
FCP (context only)1.8 s or less1.8 to 3 sover 3 s

Ranges from Google's PageSpeed Insights documentation. Every field value is read at the 75th percentile of visits.

A page passes the Core Web Vitals assessment when all three sit in the good range at the 75th percentile. If there isn't enough interaction data to report INP, LCP and CLS settle it between them. The assessment is pass or fail, so 1.9 seconds and 2.4 seconds both count as good. Once all three are green, further gains are for your visitors rather than for the report card.

First Contentful Paint appears in the same block. It marks the moment anything at all is drawn, which is useful context, but it isn't one of the three.

If an older report still talks about FID

Until March 12, 2024, the responsiveness slot belonged to First Input Delay. On that date INP took its place as a Core Web Vital, and Google removed FID from Search Console at the same moment. An audit, proposal or monthly agency report that still grades your site on FID is working from a playbook more than two years out of date.

What the PageSpeed score actually measures

The big number in the circle comes from the lab run alone. No field data goes into it. It blends five lab measurements, and Google's Lighthouse documentation gives the current weighting:

Lab metricShareWhat it stands for
Total Blocking Time30%How long scripts keep the browser too busy to respond during load. The lab's proxy for INP.
Largest Contentful Paint25%When the main content appears
Cumulative Layout Shift25%How much the layout jumps
First Contentful Paint10%When anything appears
Speed Index10%How quickly the visible area fills in

Weights from Google's Lighthouse scoring documentation. The Lighthouse 13 release notes say that version left scoring unchanged.

Two things follow from that table. First, Total Blocking Time carries the largest single share, and it's mostly about JavaScript. A page can have a small, quick hero image and still land in orange because a pile of scripts keeps the browser occupied. Second, the lab can't tap anything, so the score never measures INP directly. TBT stands in for it, and web.dev points out that a page can look fine on TBT and still respond slowly for real visitors.

Each metric is scored against real websites tracked by HTTP Archive. A value equal to the 25th percentile of that data scores 50, and a value equal to the 8th percentile scores 90. Put another way, a 90 on a metric puts your page at roughly the edge of the fastest 8 percent of sites in the dataset, which is also why the last few points are the hardest to find. Overall, 90 and above is rated good, 50 to 89 needs improvement, and below 50 is poor.

Numbers you can stop worrying about

  • A single run. Read the range across three, not the best or worst of them.
  • The desktop score on its own. It's measured on an emulated wired connection. A strong desktop number says very little about the phone in your customer's hand.
  • Suggestions that would save a sliver. The lab section lists insights about render-blocking requests, image delivery, third parties and the LCP breakdown. Some point at a few kilobytes or a fraction of a second, and those are rarely worth a developer's billable hour.
  • One tool's score against another's. Different testing tools use different devices, connections and test locations, so their numbers don't convert. Compare a tool with itself over time.
  • A competitor's score. It tells you nothing about how your own visitors are doing.
  • The Accessibility, Best Practices and SEO circles, as speed. They're checks worth reading, but none of them is a speed measurement, and a perfect SEO circle only means some basic on-page checks passed.

What does deserve your attention

In order: whether the field assessment on mobile passed or failed; which of the three metrics is failing; and, down in the lab section, which element is your LCP and how much blocking time scripts are adding. Those four facts are usually enough to know where the fix lives.

On rankings

Google's Search documentation says good Core Web Vitals line up with "what our core ranking systems seek to reward" and recommends that site owners achieve them. Treat that as a reason to fix a failing site, not as a promise that the fastest site in your trade gets the top spot. Speed sits alongside relevance; it doesn't stand in for it.

What usually slows a small business site down

The causes on local service sites are rarely exotic. Most slow reports trace back to some mix of the following.

Photos uploaded straight off a phone or camera

A photo from a current phone is thousands of pixels wide. The space it fills on a phone screen is a small fraction of that, yet the browser downloads the whole file before shrinking it to fit. Because that photo is so often the LCP element, the waste lands on the metric with the most at stake. The fix is unglamorous: resize it to the dimensions it's shown at, export it as WebP or AVIF (the formats web.dev recommends over older ones), and make sure the hero isn't lazy-loaded. Lazy loading is right for photos further down the page and wrong for the first one; Google's LCP guide says never to lazy-load the LCP image.

Page builders

Visual builders let anyone assemble a page from drag-and-drop blocks, and every block brings its own markup, styles and scripts. Builders can load styles and scripts for widgets a page never uses, and a plain two-column section can sit inside several layers of nested containers. None of it is visible. All of it gets downloaded and processed, and on an emulated mid-tier phone it shows up as blocking time and a later LCP.

Plugin stacks

On WordPress, nearly every feature arrives as a plugin: forms, sliders, pop-ups, SEO, security, caching, a review feed, a cookie banner. Each one can attach a stylesheet and a script to every page, and some add work on the server before the page is even sent, which surfaces as a slow server response. A dozen plugins from a dozen authors don't coordinate with each other, and some of them were installed to patch speed problems the others caused.

Third-party scripts

This is code your site pulls from someone else's server: the chat bubble, the review carousel, the booking widget, an embedded YouTube video, the Meta pixel, a heat-mapping tool somebody trialled once and never removed. Google's web.dev guidance on third-party JavaScript names the costs: scripts that keep the browser's main thread busy, extra connections to extra servers, and content held back until they finish. Loading them with async or defer helps, but it doesn't make them free. The first test for each one is the one Google itself suggests: if it doesn't add clear value, take it out.

Slow hosting and uncached pages

Before the browser can draw anything, it has to receive the first byte of HTML. Google's LCP guide counts that wait, Time to First Byte, as the first of LCP's four parts, so a slow start is added to LCP in full before anything else begins. Bargain shared hosting, a server a long way from your customers, or a site that rebuilds each page from a database on every visit all add to it. Our hosting page explains how we serve sites from Cloudflare's network instead of a single box.

Space that isn't reserved in advance

Layout shift has its own short list of causes. web.dev's CLS guide names images without width and height set, embeds and iframes with no dimensions, banners or forms injected after the page has drawn, and web fonts swapping in at a different size than the fallback. The fixes are usually cheap: tell the browser how much room something needs before it arrives, and the page has no reason to move.

What the report showsWhere to look first
LCP failing, and the LCP element is a photoImage file size and format; whether the hero is lazy-loaded
LCP failing, and the LCP element is textWeb fonts, render-blocking stylesheets and scripts, server response
High Total Blocking TimePage builder, plugins, chat and review widgets
INP failing in the fieldScripts that run when people tap: menus, sliders, chat, form validation
CLS above 0.1Images without dimensions, banners added at the top, late fonts
Slow server responseHosting plan, caching, distance to the server

Starting points, not diagnoses. The insights list under the lab results usually names the specific file.

What to do once you've read it

  1. Record a baseline. The mobile field assessment if there is one, the three field values, the range of lab scores from three runs, and what the LCP element is. Screenshot it with the date showing.
  2. Fix the cheap things first. A resized hero image and the removal of scripts nobody uses often move LCP and blocking time together, and neither needs a redesign.
  3. Re-run the lab test straight after each change. It responds immediately, which makes it the right tool for checking a fix landed.
  4. Give the field data a month. Because it covers the previous 28 days, an improvement blends in over about four weeks as older visits roll out of the window. When you start validation on an issue in Search Console's Core Web Vitals report, it monitors your pages for 28 days and calls the issue fixed only if no URL shows it in that window.
  5. If you're paying for clicks, test the landing page. Paid visitors arrive on the ad's destination, not the homepage, and every second they wait there is spent on your budget before they've read a word.

Questions to put to whoever built your site

  • Which element is the LCP on mobile, and what is it waiting on?
  • Which scripts load on every page, and which could go or wait until they're needed?
  • Is the hero image lazy-loaded, and what size is the file?
  • How long does the server take to send the first byte, and where is the site hosted?
  • Do the images and embeds have dimensions set so the layout doesn't jump?

Specific questions get specific answers. "Can you make it faster?" tends to get a caching plugin.

How we build sites to test well

Our sites are written by hand: no WordPress, no page builder, no plugin stack. Styles ship inside each page's HTML rather than in separate files, photos are resized and converted before they go up, and a script gets added only when a feature on the page needs one. We build to score 100 in Lighthouse on mobile and desktop. On the Measure plan, keeping Core Web Vitals in the green is part of the monthly work, alongside watching Search Console.

A lab 100 doesn't promise an instant page to someone on an old phone at the edge of coverage. It means the page itself isn't the reason they're waiting. If you want the longer version of how we put a site together, it's on our web design page, and the server side is covered on the hosting page.

Speed test questions owners ask

Why does my PageSpeed Insights score change every time I run it?

Because the conditions behind it change. Google's Lighthouse documentation puts much of the variation down to things outside the tool: changes in internet routing, different test hardware, ads or A/B tests that change what loads, and browser extensions or antivirus software when you run it on your own machine. Run it a few times and go by the range.

Why is my mobile score so much lower than my desktop score?

The mobile run emulates a mid-tier phone on a mobile network; the desktop run emulates a computer on a wired connection. It's the same page with far less processing power and bandwidth behind it. The mobile figure is the closer match to someone searching for you from their phone.

PageSpeed Insights gives me a 96 but Search Console says my pages need improvement. Which is right?

Both, about different things. The 96 is one lab load. Search Console's Core Web Vitals report is built from CrUX field data on real visits, with similar pages grouped together. When they disagree, go with the field data: real visitors are running into something the lab run didn't.

Do I need a 100 to rank on Google?

No. The score is a lab diagnostic. What Google's Search documentation points to is good Core Web Vitals measured on real visits, and even those sit alongside relevance rather than replacing it. Google's page experience documentation adds that good scores don't guarantee a top ranking.

How long after a fix does the field data catch up?

The field data covers a rolling 28 days, so an improvement shows up gradually over about four weeks as older, slower visits drop out. The lab result changes the moment you run it again.

Is a speed test from another website the same as PageSpeed Insights?

Not quite. Other tools run their own lab tests on their own devices, connections and locations, and some grade on a scale of their own. They're handy as a second opinion, but a result from one won't line up with another. Pick one, test the same pages the same way each time, and compare against your own history.

Can a WordPress site pass Core Web Vitals?

Yes. It takes discipline: a lightweight theme, few plugins, properly sized images, caching, and someone re-testing after every update. The difference between a WordPress site and a hand-coded one is how much ongoing effort it takes to stay green, not whether green is possible.

Built to pass

Rather not babysit a speed score?

Hand-coded sites from $99 a month with hosting included. On Measure, at $199 a month, keeping Core Web Vitals green is our job.

See pricing
← Back to journal