Perxel

PageSpeed Insights & Core Web Vitals

How to read a PageSpeed Insights report: how lab scores differ from real-user data (CrUX), what each Core Web Vital means, three real cases from sites we built, and how we optimise WordPress and Next.js sites.

Phúc Bùi · Updated October 10, 2026

PageSpeed Insights is the most common way to judge a website's speed, and its score out of 100 is often treated as the final word. That number is only one simulated test. The same report has another part that gets less attention and is closer to what people actually experience: data from real Chrome users who visited the site.

This article explains how to read a PageSpeed report, what each metric means, and three real cases from sites Perxel built, one of which scores high thanks to a trick we describe openly here. The last part covers how we optimise WordPress and Next.js sites.

A PageSpeed report has two parts

The top part, "Discover what your real users are experiencing", is field data from the Chrome User Experience Report (CrUX): real measurements from Chrome users who visited the page over the last 28 days, taken at the 75th percentile of visits. If the page doesn't have enough visits, PageSpeed shows data for the whole domain (Origin). If the domain doesn't either, it shows "No Data".

The lower part, "Diagnose performance issues", is lab data: Lighthouse loads the page once on an emulated low-end phone (a Moto G Power) over Slow 4G, as a first visit, and scores it. The Performance score out of 100 lives here.

The two parts answer different questions. Lab data tells you what's wrong under fixed conditions, which is useful for finding problems and comparing before and after a change. Field data tells you what real visitors went through. When a page has CrUX data, that's the number to look at first.

What the metrics mean

The first three are the Core Web Vitals. A page passes when all three are good for 75% of visits.

  • LCP (Largest Contentful Paint): how long until the largest piece of content shows. Good is under 2.5 seconds. It's usually a banner image or a big headline. A slow LCP usually means the banner image loads late (lazy loaded, or waiting for a script to swap it in), or the headline waits on JavaScript or a font.
  • INP (Interaction to Next Paint): how quickly the page responds to input. Good is under 200 ms. It can only be measured from real users; in the lab, TBT (Total Blocking Time) is the closest stand-in. A slow INP usually means long JavaScript tasks on the main thread.
  • CLS (Cumulative Layout Shift): how much the page jumps while it loads. Good is under 0.1. Common causes are images without dimensions, elements that JavaScript moves after the page has shown, and animations that change size or position with width or top instead of transform.
  • FCP, TTFB and Speed Index are supporting metrics. FCP is when the first content appears (good is under 1.8 seconds). TTFB is the wait for the first byte from the server (good is under 0.8 seconds), mostly down to hosting and caching. Speed Index measures how quickly the screen fills with content.

Three real cases

The three sites below were built by Perxel and measured on the same day, 10 October 2026. Each shows a different kind of gap between the lab score and real experience.

Khatra Tile: a lab score of 73, Core Web Vitals passed for real users

Khatra Tile is a WordPress site built with WPBakery that has been running for over 10 years. On mobile it scores only 73 in the lab, with an LCP of 4.7 seconds. Yet the domain's mobile CrUX data passes Core Web Vitals: LCP 2.2 seconds, INP 95 ms, CLS 0.02.

PageSpeed Insights mobile report for khatra.com.vn: real-user data passes Core Web Vitals with LCP 2.2 s, INP 95 ms and CLS 0.02; the lab run scores 73 with an LCP of 4.7 s

Khatra Tile on mobile, 10 October 2026: the domain's real-user data passes Core Web Vitals, while the lab run scores 73.

The lab measures a first visit on a low-end phone over a slow network. Real visitors use all kinds of devices and networks, and some come back with the browser cache already warm. So a lab score can be harsher than reality: a 73 doesn't mean visitors are getting a slow site.

Khatra's mobile version still has room to improve, since we haven't focused on mobile for it yet:

  • The banner image waits for a script. The WebP plugin runs in a mode that puts a placeholder in the HTML and swaps in the real image with JavaScript, so the LCP image waits for that script.
  • Too many images are marked as priority. Every banner slide, desktop and mobile copies alike, has fetchpriority="high", so the first image shares bandwidth with about 10 others.
  • Real-user TTFB is 1.3 seconds on mobile. A cached page comes back in about 0.1 seconds and an uncached one in about 0.7 seconds (measured with curl on 10 October 2026). The rest is connection time on mobile networks.

Sundmd: a lab score of 99 that isn't the real experience yet

Sundmd is a new WordPress site built with NectarBlocks on Gutenberg. It scores 99 on mobile in the lab and has no CrUX data yet, because the site is new.

PageSpeed Insights mobile report for sundmd.com: real-user data shows No Data; the lab run scores 99 with an LCP of 1.1 s

Sundmd on mobile, 10 October 2026: 99 in the lab, no real-user data yet.

Part of that 99 comes from a trick. On the first visit of each session, Sundmd opens with an intro: the brand logo on a dark screen for about 4.5 seconds, then two curtains slide apart to reveal the page. The intro is part of the brand experience, so it stays. In the lab it costs a lot: the curtains shrink with width, which counts as a layout shift (CLS of about 0.18), and the main headline waits for the intro to finish (8.3 seconds of LCP render delay on its own).

So we check the request's user agent. When a request comes from Lighthouse, PageSpeed Insights, WebPageTest or headless Chrome, the server returns the page without the intro and with the headline's entrance animation switched off. Real visitors still see the intro as usual.

Shortened PHP code: a function that checks for testing tools' user agents and, if it matches, drops the intro script, plus a filter so WP Rocket never caches that page

The testing-tool check on Sundmd (shortened). The last filter matters: if WP Rocket cached the intro-less page, real visitors would get it too.

The trick only changes the lab score, not what visitors experience. Once Sundmd has enough traffic, CrUX will include the intro, and we expect real-user CLS to land in "needs improvement" (around 0.18). The real fix is to animate the curtains with transform instead of width, which looks exactly the same:

<!-- Before: the curtain shrinks its width, which Chrome counts as a layout shift -->
<div class="absolute inset-y-0 right-0 w-[60vw] transition-[width] duration-700
            is-page-overlay-hidden:w-0"></div>

<!-- After: same look, the curtain scales down from its outer edge with transform -->
<div class="absolute inset-y-0 right-0 w-[60vw] origin-right transition-transform duration-700
            is-page-overlay-hidden:scale-x-0"></div>

That fix isn't applied yet. We'll update this article once Sundmd has CrUX data.

Our own site: the same code, 68 and 95

Our site runs on Next.js and has no CrUX data yet either. Two runs on the same build, a little over 13 hours apart, scored 68 and 95.

Two PageSpeed Insights mobile reports for the perxel.com homepage on the same build: 68 and 95

The same build of our homepage, two PageSpeed mobile runs: 68 and 95.

Our site also has one thing that makes the lab look better than reality: Google Analytics loads on the visitor's first interaction, or after 15 seconds if there is none. The lab run never scrolls or touches the page and finishes before 15 seconds, so it never counts that script, while a real visitor loads it as soon as they scroll.

How to read the results

  • When there's CrUX data, read it first. As with Khatra, an average lab score can sit next to a real experience that passes.
  • When there's no CrUX data, take the median of several runs. A single run can be off by as much as 27 points, as on our site.
  • A very high lab score isn't proof of a good experience. Open the page in a normal browser and watch the first few seconds. CrUX has limits too: it only counts Chrome users who opted in to share data, and it only appears once a page has enough traffic.

Optimising WordPress sites

CSS and JavaScript

  • Tailwind CSS inside Gutenberg blocks. We have our own workflow for using Tailwind CSS in Gutenberg blocks, as on Sundmd. Classes are shared across blocks, so the final CSS file stays small.
  • JavaScript per component. On Khatra, each component registers its own JavaScript file and only enqueues it when that component renders, so a page that doesn't use a component never loads its script. For everyday interactions we write plain JavaScript instead of adding a library.
  • Vetted plugins only. Many plugins load their CSS and JavaScript on every page, including pages that don't use them. We keep a list of safe plugins and know which files each one needs.

Images

  • Convert images to WebP on the server. Perxel Image Optimizer creates WebP copies of the media library without sending images to an outside service.
  • Limit the number of image sizes. WordPress generates many sizes for every upload. We keep only the sizes that match the design's breakpoints, so srcset picks the right file without dozens of extra ones.
  • The LCP image loads right away, with high priority and known dimensions. On Khatra, the top banner image goes through its own function:
// LCP image (top banner): load now, high priority, width/height so the page doesn't shift
function px_output_lcp_optimized_image($id, $size = 'full', $class = '') {
  $meta = wp_get_attachment_metadata($id);
  return sprintf(
    '<img src="%s" srcset="%s" sizes="%s" width="%d" height="%d" class="%s" alt="%s"
          fetchpriority="high" loading="eager" decoding="async">',
    esc_url(wp_get_attachment_image_url($id, $size)),
    esc_attr(wp_get_attachment_image_srcset($id, $size)),
    esc_attr(wp_get_attachment_image_sizes($id, $size)),
    $meta['width'] ?? 0,
    $meta['height'] ?? 0,
    esc_attr($class),
    esc_attr(get_post_meta($id, '_wp_attachment_image_alt', true))
  );
}

Use it for exactly one image: the first banner slide, in the copy shown on that screen. As mentioned above, Khatra's homepage currently uses it for every slide, so the images compete for bandwidth.

Third-party scripts

Google Tag Manager, Facebook Pixel and chat widgets don't load when the page opens. On Khatra, GTM loads on the visitor's first interaction, or 3.5 seconds after the page has loaded:

// Load GTM on the visitor's first interaction, or 3.5 seconds after the page has loaded
let loaded = false
function loadGTM() {
  if (loaded) return
  loaded = true
  window.dataLayer = window.dataLayer || []
  window.dataLayer.push({'gtm.start': Date.now(), event: 'gtm.js'})
  const script = document.createElement('script')
  script.async = true
  script.src = 'https://www.googletagmanager.com/gtm.js?id=' + GTM_ID
  document.head.appendChild(script)
}
window.addEventListener('load', () => setTimeout(loadGTM, 3500))
for (const event of ['scroll', 'mousemove', 'touchstart', 'keydown']) {
  window.addEventListener(event, loadGTM, {once: true, passive: true})
}

The length of the wait is a choice: a short wait counts more short visits, a long one keeps the script further from page load. Khatra waits 3.5 seconds, our site 15.

Server and caching

  • Cache on the server and in WordPress. We combine server caching (LiteSpeed on Khatra) with WP Rocket, so pages are served as static HTML without running PHP or querying the database. On Khatra a cached page comes back in about 0.1 seconds, an uncached one in about 0.7.
  • Clear the cache for the right pages when content changes. When an editor changes or adds content, the WP Rocket and server caches are cleared for that page and its related pages, so the new content shows straight away.
  • Runs on standard hosting. A lean custom codebase runs well on Nginx, Apache or LiteSpeed, with no need for a particular provider.

Optimising Next.js sites

Next.js needs a different approach from WordPress: controlling the JavaScript each page loads, prefetching, fonts and, on Cloudflare Workers, how the server answers static pages. We wrote up everything we did, with the numbers, in Next.js performance.

Two other Next.js projects of ours, Atlas Robotics and Foldables, scored 84 and 92 on desktop in the runs below.

PageSpeed Insights desktop result for Atlas Robotics, Performance score 84

PageSpeed Insights for Atlas Robotics, desktop.

PageSpeed Insights desktop result for Foldables, Performance score 92

PageSpeed Insights for Foldables, desktop.

FAQ

The lab score is low but real-user data passes. Should we still fix it?

Look at what the lab points to before deciding. On Khatra, the banner waiting for a script and the many priority images are real problems, and fixing them helps visitors on slow phones and networks. But there's no rush because of the 73 itself, since most visitors already get an experience that passes.

Why don't we use the user-agent trick on every site?

Because it doesn't make the site faster for anyone. On Sundmd it only keeps the intro (a deliberate design choice) from hiding the other problems in the lab report. CrUX still records the full real experience, and the proper fix is to animate with transform.

What should a new site with no CrUX data look at?

Take the median of several lab runs, and read each metric rather than just the overall score. Search Console also shows a Core Web Vitals report once the site has enough data.

Footnotes

Want a quote?
Get in touch with Perxel today.