Quick answer: Core Web Vitals are three Google metrics that measure important parts of the real user experience: loading, interactivity and visual stability. The current metrics are Largest Contentful Paint (LCP), Interaction to Next Paint (INP) and Cumulative Layout Shift (CLS). A good result at the 75th percentile is LCP of 2.5 seconds or less, INP of 200 milliseconds or less, and CLS of 0.1 or less.
These metrics help website owners find performance problems that visitors actually experience. This guide explains each metric, its thresholds, how to measure it and what to fix first—whether you use WordPress, Shopify or a custom website.
What are Core Web Vitals?
Core Web Vitals are a set of user-focused performance metrics developed by Google. They measure three important experiences:
- Loading: how quickly the main content becomes visible.
- Interactivity: how quickly the page responds when a visitor interacts with it.
- Visual stability: whether page elements stay in the expected position as the page loads.
The metrics are part of Google’s broader page experience guidance. They are useful for improving usability, but they are not a substitute for relevant content, helpful information or sound technical SEO. Passing Core Web Vitals does not guarantee high rankings.
The three Core Web Vitals and their good thresholds
Google evaluates these metrics at the 75th percentile of page visits, separately for mobile and desktop. In simple terms, at least 75% of measured visits should meet the good threshold for a page to receive a good assessment for that metric.
| Metric | What it measures | Good | Needs improvement | Poor |
|---|---|---|---|---|
| Largest Contentful Paint (LCP) | Loading of the largest visible image or text block | ≤ 2.5 seconds | 2.5–4 seconds | > 4 seconds |
| Interaction to Next Paint (INP) | Responsiveness to user interactions | ≤ 200 ms | 200–500 ms | > 500 ms |
| Cumulative Layout Shift (CLS) | Unexpected layout movement | ≤ 0.1 | 0.1–0.25 | > 0.25 |
Do not confuse these thresholds with a single overall website speed score. Each metric is assessed separately, and mobile and desktop results can be different.
1. Largest Contentful Paint (LCP): loading performance
LCP measures how long it takes for the largest image or text block in the visible area to render. This is often a hero image, featured image, large heading or main content block. It helps answer: “How soon can the visitor see the main content?”
Common causes of poor LCP
- Slow server response or an overloaded hosting environment.
- Large, uncompressed hero images.
- Important images discovered late because of CSS or JavaScript.
- Render-blocking CSS and JavaScript.
- Slow font loading or too many third-party resources.
How to improve LCP
- Improve server response time with suitable hosting, caching and a content delivery network (CDN).
- Resize and compress the main image; use modern formats such as WebP or AVIF where supported.
- Do not lazy-load the main above-the-fold hero image. Make it discoverable early, and consider appropriate preload or fetch priority when testing shows it helps.
- Remove or defer non-critical scripts and reduce render-blocking resources.
- Use efficient fonts and avoid loading unnecessary font weights.
2. Interaction to Next Paint (INP): responsiveness
INP measures the responsiveness of a page to user interactions, such as clicks, taps and keyboard input. It looks at the delay from an interaction until the next visual update. INP replaced First Input Delay (FID) as a Core Web Vital in March 2024.
A page can appear to load quickly but still feel slow when a visitor opens a menu, applies a filter, submits a form or adds a product to a cart. INP helps reveal those problems.
Common causes of poor INP
- Long JavaScript tasks that block the browser’s main thread.
- Large scripts from themes, plugins, apps or third-party tools.
- Heavy event handlers that do too much work after a click.
- Complex page updates that take too long to render.
- Excessive tracking, chat widgets and advertising scripts.
How to improve INP
- Break long JavaScript tasks into smaller pieces and avoid unnecessary work on the main thread.
- Remove unused scripts and review the impact of third-party tools.
- Keep event handlers small and move non-urgent work out of the immediate interaction path.
- Reduce unnecessary DOM updates and simplify complex interface components.
- Test real interactions on mid-range mobile devices, not only on a powerful desktop computer.
3. Cumulative Layout Shift (CLS): visual stability
CLS measures unexpected movement of visible page elements. For example, a visitor starts to tap a button, but an advertisement loads above it and pushes the button down. The visitor may tap the wrong item.
Common causes of poor CLS
- Images or videos without reserved dimensions or aspect ratios.
- Ads, embeds or banners inserted into the page after content appears.
- Web fonts that cause text to reflow when they load.
- Content dynamically inserted above existing content.
- Animations that change layout instead of using transform or opacity.
How to improve CLS
- Set width and height attributes or an aspect ratio for images and video.
- Reserve space for ads, embeds, cookie banners and other dynamic components.
- Avoid inserting new content above existing content unless it follows a user action.
- Use font loading strategies that reduce unexpected text movement.
- Prefer animations that do not trigger layout changes.
Core Web Vitals vs general page speed metrics
Page speed is a broad term covering many technical measurements, such as server response, file size and resource loading. Core Web Vitals focus on three specific user experiences. A page can have a good total load time but still respond slowly to clicks or shift unexpectedly.
Use both types of measurements. For example, Time to First Byte (TTFB) can help diagnose server delays that contribute to LCP, while JavaScript execution traces can help explain poor INP. These supporting metrics are diagnostic tools, not additional Core Web Vitals.
Read our related guide to page speed optimization basics for more performance improvements.
How to measure Core Web Vitals
Use both field data and lab tests. They answer different questions, so do not treat one report as the complete picture.
Field data: real user experience
Field data comes from real visits and reflects the devices, networks and conditions people use. Google’s Chrome User Experience Report (CrUX) provides the data used by several Google tools. Search Console’s Core Web Vitals report groups URLs with similar performance issues when sufficient data is available.
- Google Search Console: view groups of URLs classified as good, needs improvement or poor, where data is available.
- PageSpeed Insights: see field data when available, alongside lab diagnostics for the tested URL.
- Chrome UX Report: explore aggregated real-world experience data for eligible pages and origins.
Lab data: controlled testing
Lab data is collected in a controlled environment, often using simulated devices and network conditions. It is useful for reproducing issues, testing code changes and finding likely causes. Lighthouse is a common lab tool, but a single Lighthouse run does not replace real-user field data.
For a practical workflow, test important page templates—not just the homepage. Include product pages, category pages, blog articles, service pages, landing pages and checkout or lead forms.
How to improve Core Web Vitals on WordPress
WordPress performance depends on hosting, theme, plugins, page builder, images, scripts and caching. A plugin alone cannot guarantee good Core Web Vitals. Start by identifying the actual issue, then test changes one at a time.
- Hosting and caching: use reliable hosting, server-side caching and a CDN where appropriate.
- Images: resize uploads, compress them and serve modern formats. Avoid lazy-loading the main hero image.
- Plugins: remove plugins you do not need and check whether essential plugins load scripts site-wide unnecessarily.
- Page builders: simplify complex layouts, widgets, animations and nested sections.
- CSS and JavaScript: remove unused assets carefully; defer or delay non-critical scripts after checking functionality.
- Fonts: limit font families and weights, and configure font loading sensibly.
- Third-party tools: review chat, analytics, advertising, heatmaps and embedded media for performance cost.
After each change, retest the same page template and check that forms, navigation, tracking and checkout still work. Aggressive optimization settings can break website features, so keep backups and use a staging site for larger changes.
A practical Core Web Vitals audit workflow
- Choose important templates: identify pages that bring organic traffic, leads or sales.
- Review Search Console: check mobile and desktop reports and note URL groups with poor field data.
- Test representative URLs: use PageSpeed Insights and inspect both field data and lab opportunities.
- Identify the largest issue: determine whether the main problem is LCP, INP or CLS before changing settings.
- Fix the cause: address server delays, image delivery, JavaScript, layout dimensions or other relevant issues.
- Retest functionality: check the page on mobile and desktop, including important user journeys.
- Monitor field data: allow enough real visits and time for updated field data to become available, then review again.
Common Core Web Vitals mistakes
- Chasing a perfect Lighthouse score: lab scores are useful, but real-user field data is needed to understand visitors’ experience.
- Lazy-loading the hero image: this can delay the main content and make LCP worse.
- Installing several optimization plugins: overlapping features can create conflicts and extra work.
- Delaying every JavaScript file: this can break menus, forms, analytics or checkout functionality.
- Testing only the homepage: different templates and page elements can have very different performance.
- Expecting an immediate ranking boost: performance improvements help user experience, but rankings depend on many factors.
Frequently asked questions
What are the three Core Web Vitals?
The three current Core Web Vitals are Largest Contentful Paint (LCP), Interaction to Next Paint (INP) and Cumulative Layout Shift (CLS). They measure loading, responsiveness and visual stability.
What is a good Core Web Vitals score?
At the 75th percentile, a good result is LCP of 2.5 seconds or less, INP of 200 milliseconds or less and CLS of 0.1 or less. Google assesses the metrics separately and reports mobile and desktop performance separately.
Is FID still a Core Web Vital?
No. Interaction to Next Paint (INP) replaced First Input Delay (FID) as a Core Web Vital in March 2024. FID is no longer one of the current three Core Web Vitals.
Do Core Web Vitals affect SEO rankings?
They are part of Google’s page experience considerations, but good scores do not guarantee higher rankings. Relevant, helpful content remains important, and page experience is only one part of a wider ranking system.
Why does PageSpeed Insights show different results each time?
Lab results can change because of network conditions, server load, browser state, test location and page variations. Field data also changes as real visitors use the page. Look for patterns across repeated tests rather than relying on one result.
Can a website pass Core Web Vitals on desktop but fail on mobile?
Yes. Mobile devices often have different processing power, screen sizes and network conditions. Google reports mobile and desktop data separately, so test and improve both experiences.
How long does it take for improvements to appear in Search Console?
It depends on how much real-user data the page receives and when the reporting dataset updates. A lab test can show an immediate change after a fix, but field reports need new visits and time to reflect the change.
Final thoughts
Core Web Vitals help you understand whether a website loads its main content quickly, responds smoothly and keeps its layout stable. Start with real-user data, find the biggest issue and fix its cause rather than chasing a perfect score. A faster, more responsive and stable website makes it easier for people to read, browse, enquire and buy.
