Your website may feel fast on your laptop and still frustrate visitors on a mid-range phone. Core Web Vitals are Google’s way of measuring that real-world experience, and they are reported separately for mobile and desktop. Mobile is usually where problems show up first, because phones have less processing power, slower networks and smaller screens.
This guide explains the three Core Web Vitals, their thresholds, how to find what is hurting each one and the fixes that work. It is written for developers and site owners, with specific advice for WordPress sites. By Biswajit Barman, founder of My Advisers, Kolkata. Last updated 18 November 2026.
The three metrics and their thresholds
| Metric | What it measures | Good | Needs improvement | Poor |
|---|---|---|---|---|
| Largest Contentful Paint (LCP) | How quickly the main content appears | 2.5 s or less | 2.5–4 s | Over 4 s |
| Interaction to Next Paint (INP) | How quickly the page responds to taps, clicks and key presses | 200 ms or less | 200–500 ms | Over 500 ms |
| Cumulative Layout Shift (CLS) | How much the layout jumps while loading | 0.1 or less | 0.1–0.25 | Over 0.25 |
Google assesses these at the 75th percentile of real visits, separately for mobile and desktop. In plain words, a page passes a metric when at least three out of four visits have a good experience. INP replaced the older First Input Delay metric in March 2024 because it looks at responsiveness across the whole visit rather than only the first interaction.
Keep these in perspective. Core Web Vitals are part of Google’s page experience signals, and they are one signal among many. Relevant, helpful content still matters most. But a slow, jumpy page loses visitors regardless of rankings, so the work pays off either way.
First, measure properly: lab data versus field data
There are two kinds of data, and mixing them up causes endless confusion.
- Field data comes from real visitors, collected through the Chrome User Experience Report. It is what Google uses for assessment. You see it in the Core Web Vitals report in Search Console and in the top section of PageSpeed Insights, when your page has enough traffic.
- Lab data comes from a simulated test, such as Lighthouse. It is repeatable and helps you debug, but it is a single run on a simulated device. The Lighthouse mobile preset simulates a slow 4G connection and a CPU slowed by a factor of four to mimic a mid-range phone.
Use field data to decide whether you have a problem and which pages are affected. Use lab data to find the cause and test fixes. After a fix, field data takes about 28 days to fully reflect the change because it is a rolling window. Do not panic if the report does not improve the next day.
A quick phone-based check is useful too. Open your key pages on a real mid-range Android phone over mobile data, not Wi-Fi, and see how they feel. A tool such as Dev Browser, our free Android app with a responsive tester, code viewer, console and SEO checker, helps you look at a page at different viewport sizes and read the console without a laptop. It is a quick first look, not a replacement for PageSpeed Insights and field data.
Fixing LCP: make the main content appear sooner
The LCP element is the largest image, video poster or block of text visible in the viewport as the page loads. On most pages it is the hero image or the main heading. PageSpeed Insights and Chrome DevTools tell you exactly which element it is. LCP time breaks into four parts, and it helps to find which one is largest:
- Time to first byte (TTFB). How long the server takes to respond.
- Resource load delay. How long before the browser starts loading the LCP resource.
- Resource load duration. How long the resource takes to download.
- Element render delay. How long before the browser paints it after it has loaded.
If TTFB is slow
- Use page caching so the server does not rebuild each page for every visit. On WordPress, use your host’s caching or one good caching plugin, not several.
- Use a content delivery network so the page is served from a location closer to your visitors. For an Indian audience, a server or CDN edge in or near India helps.
- Check hosting quality and PHP version. A slow server cannot be fixed by a faster theme. A TTFB under roughly 800 ms is a common guideline for a good starting point.
- Reduce slow database queries and heavy plugins that run on every request.
If the load delay is long
- Make sure the hero image is in the HTML as a normal image, not injected later by JavaScript or hidden in a CSS background that the browser discovers late.
- Do not lazy-load the LCP image. Lazy loading is for images below the fold. Add fetchpriority=”high” to the hero image to tell the browser it matters.
- Preload the LCP image or font if the browser cannot discover it early, and preconnect to important third-party origins.
If the download is slow
- Compress the image and resize it to the size it is displayed at. A 4,000-pixel-wide photo shown at 400 pixels wastes bandwidth.
- Use modern formats such as WebP or AVIF where supported.
- Use srcset and sizes so phones download a smaller file than desktops.
If the render delay is long
- Remove or defer render-blocking CSS and JavaScript. Inline the small amount of critical CSS needed for the top of the page, and load the rest later.
- Avoid hiding the page until a script runs, as some A/B testing and cookie tools do.
- Use font-display: swap so text appears immediately in a fallback font, and limit the number of font files and weights.
Fixing INP: make the page respond quickly
INP records how long it takes from a tap, click or key press until the browser can paint the next frame, and reports a value near the worst interaction on the page. Poor INP almost always means the main thread, the single thread that runs JavaScript and handles input, is busy when the user acts. Any task running longer than 50 milliseconds is a “long task” and can delay a response.
Find the culprit
Record a trace in Chrome DevTools’ Performance panel with CPU throttling set to 4× or 6× slowdown, interact with the page, and look for long tasks around your interactions. The three parts of an interaction are input delay (waiting for the main thread), processing time (your event handlers) and presentation delay (rendering the result). Each has different fixes.
Fixes that usually help
- Cut third-party scripts. Chat widgets, tag managers, social embeds, heatmaps and ad scripts are the most frequent cause on WordPress sites. Remove what you do not need and load the rest after the page is interactive.
- Break up long tasks. Split heavy work into smaller chunks and yield back to the browser between them, for example with setTimeout or scheduler.yield where available, so input can be handled in between.
- Keep event handlers light. Do the minimum needed to show feedback immediately, and defer the rest.
- Reduce the DOM size. Pages with thousands of elements make every style recalculation and layout slower. Avoid deeply nested page-builder markup.
- Avoid layout thrashing. Reading layout properties and writing styles in a loop forces repeated layout work. Batch reads and writes.
- Load less JavaScript. Remove unused plugins, split bundles, and avoid shipping a large framework for a mostly static page.
On mobile, a menu that opens late, a button that does nothing for half a second or a filter that freezes the page are typical symptoms. Test these specific interactions on a real phone.
Fixing CLS: stop the page jumping
CLS adds up unexpected layout shifts during the visit. Everyone has tapped a button just as an ad loaded and pushed it away. The cause is almost always content arriving without reserved space.
- Set image and video dimensions. Add width and height attributes, or use the CSS aspect-ratio property, so the browser reserves space before the file loads. WordPress adds these to images by default in current versions, but page builders and custom code may remove them.
- Reserve space for ads, embeds and iframes. Give the container a fixed minimum height that matches the usual content.
- Do not insert content above existing content. Cookie banners and promotional bars that push the page down after load are a frequent cause. Overlay them or reserve their space from the start.
- Handle web fonts carefully. A font swap can reflow text. Preload the key font, and use the size-adjust and related descriptors, or choose a fallback font with similar metrics.
- Animate with transform and opacity. Animating properties like top, height or margin triggers layout shifts.
- Be careful with lazy-loaded content that changes height. Placeholders should match the final size.
Chrome DevTools can highlight layout shift regions, and the Layout Shifts track in the Performance panel lists each shift and the element responsible.
WordPress-specific checklist
- Use a lightweight, well-coded theme. Heavy multipurpose themes and visual page builders often add large scripts and deeply nested markup.
- Deactivate and delete plugins you do not use, and replace several single-purpose plugins with one well-built one where possible.
- Use one caching solution, from your host or a single plugin, and test after enabling any minification or “delay JavaScript” option, since aggressive settings can break menus and forms.
- Optimise images at upload, and use responsive image output, WebP and lazy loading below the fold only.
- Limit fonts to one or two families and the weights you use.
- Keep WordPress, PHP, the theme and plugins updated, after taking a backup.
Our free WordPress theme, Advisers Multipurpose, is built on native blocks so that you do not need a heavy page builder. See our complete guide to the theme for setup and speed tips.
A practical order of work
- Open the Core Web Vitals report in Search Console and note which metric and which page groups are failing on mobile.
- Run PageSpeed Insights on one representative failing URL and read the diagnostics.
- Fix server and caching issues first, because they affect every page.
- Fix the LCP element: usually the hero image’s size, format, priority and discovery.
- Remove or defer the heaviest third-party scripts.
- Add dimensions and reserve space to stop layout shifts.
- Re-test in the lab, deploy, and use “Validate fix” in Search Console.
- Wait for field data to update, and monitor monthly.
Common mistakes
- Chasing a perfect Lighthouse score instead of the field data that Google actually uses.
- Lazy-loading the hero image, which delays LCP.
- Testing only on a fast laptop and office Wi-Fi.
- Installing a “speed plugin” and ticking every option without testing the site.
- Ignoring third-party scripts, which are often the largest cause of poor INP.
- Expecting instant change in Search Console, which uses a rolling 28-day window.
Frequently asked questions
Do Core Web Vitals directly affect rankings?
They are part of Google’s page experience signals, but relevance and content quality carry far more weight. Treat them as a tie-breaker and, more importantly, a way to keep visitors.
Why is my mobile score worse than desktop?
Phones have slower processors and often slower networks, and lab tests simulate this on purpose. Mobile is the more demanding test.
Why does Search Console show no data for my page?
Field data needs enough real visits. Low-traffic pages may have no data, in which case use lab tests and group-level data.
What is a good first fix if I only have an hour?
Compress and correctly size your hero image, remove lazy loading from it, add width and height to images, and remove one heavy third-party script. Together these often improve LCP and CLS noticeably.
How often should I check Core Web Vitals?
Monthly for most sites, and after any significant change such as a new theme, plugin, ad network or page builder update.
For a fuller testing routine, read our responsive web design testing checklist and the Dev Browser guide, or get the app on Google Play. All our free tools are on the products page.
Thresholds and tool behaviour reflect commonly published guidance at the time of writing and may change. Verify against current Google documentation.