We rechecked official Google Search Central, web.dev, and Chrome UX Report materials on July 29, 2026. Specifications and tool interfaces change, so consult official information before implementation too.
The key to improving Core Web Vitals is to identify problems in the field, reproduce causes in the lab, and verify in the field after release. Improving only the overall Lighthouse score can miss pages or interactions that real users experience as slow.
Use Core Web Vitals to understand where users wait, not just whether three metrics pass
The current Core Web Vitals are LCP, INP, and CLS. Good thresholds are LCP at or below 2.5 seconds, INP at or below 200 milliseconds, and CLS at or below 0.1. Evaluate mobile and desktop separately at the 75th percentile of page loads.
| Current metrics | LCP (loading), INP (responsiveness), and CLS (visual stability) |
|---|---|
| Good thresholds | LCP ≤ 2.5 seconds, INP ≤ 200 milliseconds, CLS ≤ 0.1 |
| Assessment | Evaluate all three at the 75th percentile, separating mobile and desktop |
| Finding problems | Search Console, PageSpeed Insights CrUX data, and your own RUM |
| Diagnosing causes | Chrome DevTools, Lighthouse, and network and Performance recordings |
| Data period | Major CrUX-based tools update a rolling 28-day aggregation daily |
| Relationship to SEO | One part of page experience; good values alone do not guarantee higher rankings |
What are Core Web Vitals? The current metrics are LCP, INP, and CLS
Core Web Vitals measure loading speed, responsiveness, and visual stability as experienced by people using web pages. They cover more than server response time: the wait for images, visual updates after a click, and layout shifts during loading also matter.
Loading
2.5 seconds or lessMeasures the time until the largest image or text block in the initial viewport is rendered.
Needs improvement: over 2.5 to 4.0 seconds / poor: over 4.0 secondsResponsiveness
200 ms or lessMeasures the time from a click, tap, or keyboard interaction until the next visual update is rendered.
Needs improvement: over 200 to 500 ms / poor: over 500 msVisual stability
0.1 or lessEvaluates the size and distance of unexpected layout shifts using a unitless score.
Needs improvement: over 0.1 to 0.25 / poor: over 0.25The 75th percentile is used instead of the average so that fast experiences do not hide slower ones. For example, with 100 page visits ordered from fastest to slowest, check whether the value around the 75th visit meets the target.
Understand the relationship between Core Web Vitals and SEO
Google explains that Core Web Vitals, along with other page-experience factors, are considered in ranking. They do not determine rankings alone. Answers to search intent, original and trustworthy content, crawling and indexing, internal links, and mobile usability also matter.
Help users achieve their goals
- Main content appears quickly
- Clicks and input receive a prompt response
- Buttons and text do not suddenly move
- Fewer abandonments and mistaken actions
Do not predict ranking or revenue from scores alone
- Good scores do not ensure high rankings if the page misses search intent
- Conversion also depends on price, messaging, navigation, and forms
- A single measurement cannot establish causation
Find problems in field data and reproduce causes in lab data
When improving Core Web Vitals, distinguish field data aggregated from real users from lab data reproduced under specified device and network conditions. They are not competing numbers; they have different roles.
| Comparison | Field data | Lab data |
|---|---|---|
| Main purpose | Find pages, devices, and metrics causing problems for real users | Reproduce problems under consistent conditions and investigate causes |
| Typical tools | CrUX, Search Console, PageSpeed Insights, and your own RUM | Lighthouse, Chrome DevTools, and WebPageTest |
| Period and conditions | Aggregates diverse devices, networks, regions, and behavior over the past 28 days | Runs with specified device, CPU, network, and cache conditions |
| INP | Can be measured from real interactions | A Lighthouse load-only run cannot measure it directly; TBT is used as a proxy |
| Use | Decide what to fix first | Decide which elements, resources, and tasks to fix |
Read PageSpeed Insights from top to bottom
Mobile or desktop?
Do not mix device categories; examine the main users and the category with problems. Mobile devices are often more constrained by CPU and network.
URL or origin data?
If URL-level samples are insufficient, origin data closer to a site-wide aggregate may appear. Always check the heading and scope.
The three real-user metrics
Check which of LCP, INP, and CLS exceed thresholds and where slow visits fall in the distribution.
Lab diagnostics and improvement opportunities
Look beyond the overall Lighthouse score to causes such as the LCP element, resource dependencies, long tasks, and layout shifts.
Narrow down affected pages and causes in five steps
Before applying the same optimization everywhere, identify which users, page groups, metrics, and elements have problems. Different causes call for different fixes.
Separate the scope by device, URL group, and metric
In Search Console, inspect mobile and desktop, URL groups, LCP, INP, CLS, and good, needs-improvement, and poor statuses. Distinguish common-template issues from a particular article's images or embeds.
Read field values and distributions for representative URLs
In PageSpeed Insights, check whether values are URL- or origin-level, the 75th percentile, and the 28-day aggregation. Do not prioritize solely by averages or Lighthouse scores.
Reproduce the symptom in the lab
Use DevTools Performance or Lighthouse to record first loads without cache, representative viewport widths, and important interactions such as menus, search, and forms.
Connect the issue to elements, resources, and tasks
Associate the LCP element with its loading path, slow interactions with long tasks, and layout shifts with their causes. Do not stop at vague statements such as heavy images or too much JavaScript.
Change one thing at a time and check functional regressions
Save baseline recordings and avoid stacking several optimizations at once. Check appearance, forms, analytics tags, advertising, accessibility, and major browsers.
| Priority | Criteria | Examples |
|---|---|---|
| A | High traffic, business importance, and shared-template impact | Home, product listings, applications, contact, and headers shared by all articles |
| B | High impact but also high change risk or verification effort | Search, filters, cart, member screens, and third-party tags |
| C | Low traffic, limited impact, or an alternative path | Old one-off articles, limited campaigns, and offscreen embeds |
Break LCP into four parts
LCP depends on more than image size. Separate server response, resource discovery, download, and rendering after download to choose effective fixes.
Speed up the first HTML response
Check application processing, databases, caching, CDNs, redirects, and hosting. Before deciding to move servers, measure representative URLs and regions under consistent cache conditions.
Make the LCP resource discoverable early from HTML
Adding the main image only after JavaScript executes or as a CSS background delays its discovery. Consider an img in the initial HTML and appropriate preload and fetchpriority.
Deliver images sized for display
Consider AVIF, WebP, compression, srcset and sizes, a CDN, and long caching. Avoid sending images much larger than their displayed width without sacrificing too much quality.
Reduce waiting on CSS, fonts, and JavaScript
Reduce CSS and synchronous scripts unnecessary for initial rendering and long main-thread work. Limit font weights and glyphs, and check fallback layout.
<link rel="preload" as="image" href="/img/hero.avif" fetchpriority="high">
<img
src="/img/hero.avif"
srcset="/img/hero-800.avif 800w, /img/hero-1400.avif 1400w"
sizes="(max-width: 760px) 100vw, 52vw"
width="1400"
height="875"
fetchpriority="high"
decoding="async"
alt="Alternative text describing the page content"
>- Check the actual LCP element in DevTools
- Determine whether TTFB, discovery delay, download, or rendering takes longest
- Ensure the LCP image is in initial HTML and not lazy-loaded
- Use srcset, sizes, and formats suited to the displayed width
- Reduce unnecessary CSS, fonts, and synchronous JavaScript
Improve INP by identifying slow interactions and shortening time to the next paint
INP measures responsiveness to clicks, taps, and keyboard input throughout a page visit. Rather than looking only at JavaScript size, identify which interaction is slow and whether the delay is input, event processing, or presentation.
Input delay
Time from user input until event processing can start. Long tasks or script evaluation occupying the main thread increase it.
Processing time
Time until event handlers complete. Large recalculations, filtering every item, synchronous work, and heavy third-party code can contribute.
Presentation delay
Time from processing completion until the next frame appears. Large DOMs, synchronous layout, and complex rendering can affect it.
Record important interactions
Prioritize actions users need to achieve their goals: menus, search suggestions, input, filtering, carts, modals, and submission.
Reduce long tasks and unnecessary JavaScript
Review code unnecessary for initial rendering, third-party tags, and large libraries; load only needed functionality.
Split event work and allow a paint first
Make the update visible to users first and move aggregation, saving, and further calculation to later tasks. Show a processing state promptly too.
Reduce alternating DOM writes and measurements
Batch reads and writes rather than alternating style changes and size measurements. Limit updates to the necessary scope.
Reserve space for sources of unexpected shifts to improve CLS
CLS is not a duration; it is calculated from how much visible content moves and how far. Check not only initial load but consent banners, ads, embeds, deferred content, and updates after interaction.
Specify dimensions or aspect ratio for images and video
Set width and height on img and video and preserve aspect ratio for responsive displays. Reserve space before loading.
Reserve space for ads, embeds, and dynamic regions
Set min-height or aspect-ratio for ads, maps, videos, forms, and notifications. Design empty states when content does not arrive.
Do not insert content unexpectedly above existing content
Reserve space for top banners or messages from the start, or use an overlay where appropriate. Ensure interaction targets do not move away.
Check web fonts and animations
Minimize size differences from fallback fonts and load only needed fonts early. Prefer transform and opacity for motion effects.
<img
src="/img/article.webp"
width="1200"
height="675"
loading="lazy"
decoding="async"
alt="Description of the article image"
>
<div class="video-frame">...</div>
<style>
.video-frame {
aspect-ratio: 16 / 9;
min-height: 220px;
}
</style>Priorities for improving Core Web Vitals in WordPress
Themes, plugins, images, fonts, ads, analytics tags, and servers overlap in WordPress, so there may be more than one cause. Identify the affected metric and element before adding a performance plugin.
Start with high-impact, lower-risk items
- Above-the-fold image size, format, and dimensions
- Unneeded plugins and third-party tags
- Font families, weights, and loading
- Caching, CDN, PHP, and databases
- CSS and JavaScript shared across the theme
Common problems with bulk optimization
- Lazy-loading the LCP image
- Breaking menus or forms by combining JavaScript
- Breaking individual pages when removing unused CSS
- Conflicts among multiple cache plugins
- Breaking analytics tags or consent management
| Order | Review and fix | Main metrics affected |
|---|---|---|
| 1 | LCP image, image dimensions, WebP / AVIF, and lazy-loading offscreen images | LCP and CLS |
| 2 | Unneeded plugins, third-party tags, and long JavaScript tasks | INP and LCP |
| 3 | Caching, CDN, PHP, database, redirects, and TTFB | LCP |
| 4 | Fonts, CSS, ad and embed space, and consent banners | CLS and LCP |
| 5 | Theme and plugin updates and regression checks in staging | All metrics and functionality |
A workflow from implementation to post-release verification
Core Web Vitals are not a one-time fix. Save a baseline, implement narrowly, check functional regressions, and assess continuously using field data after release.
Save the baseline
Record URL, date and time, device, network and CPU conditions, cache, login state, consent banners, number of runs, LCP element, and representative interactions.
Write a one-sentence hypothesis
Connect cause to expected effect: for example, reducing hero-image discovery delay may improve LCP, or splitting a full search-suggestion recalculation may improve INP.
Implement one change at a time in staging
Limit the scope and check Chrome, Edge, Safari, mobile, keyboard, text enlargement, forms, images, and analytics tags.
Run multiple lab measurements under consistent conditions
Look at trends across runs rather than a single result. Check for regressions in other metrics and functionality even when the target metric improves.
Record the release date and version
This allows comparison with post-release RUM and CrUX trends. Record concurrent changes in advertising, campaigns, and traffic mix too.
Track daily with the 28-day window in mind
CrUX-based data includes the previous 28 days, so it does not fully refresh immediately after release. Monitor early regressions with lab data and your own RUM while following field distributions.
Final pre-release checklist
- Compare before and after with the same URL, device, and network conditions
- Identify the actual LCP element, slow interaction, and causes of layout shifts
- Check other Core Web Vitals as well as the target metric
- Confirm major forms, search, menus, checkout, and login work
- Check rendering in Chrome, Edge, Safari, and real mobile devices
- Check accessibility, analytics tags, and consent management for regressions
- Record the release date, changes, owner, and version
Seven common Core Web Vitals mistakes
Using only the Lighthouse score as a KPI
The overall score is a diagnostic starting point. Also examine real-user LCP, INP, and CLS and whether users can complete their goals.
Looking only at averages
Even a fast average can hide problems on slower devices or networks. Inspect the 75th percentile and distributions.
Trying to fix LCP with image compression alone
If TTFB, discovery delay, or render blocking is the main cause, reducing image size alone has limited effect.
Judging INP only from initial loading
INP covers interactions throughout a page visit. Record actual search, input, menus, modals, and other interactions.
Checking CLS only on reload
Shifts can also occur with consent banners, ads, deferred content, infinite scrolling, and notifications after interactions.
Enabling multiple optimizations at once
It becomes hard to tell what helped or broke something. Keep changes small and record results and regression checks.
Declaring failure from CrUX immediately after release
Because the prior 28 days remain in the data, assess lab results, RUM, release dates, and daily trends together.
Official sources consulted
We checked the following official sources for metrics, thresholds, measurement periods, and improvements on July 29, 2026. Specifications and tool interfaces change, so check again before implementation.
Frequently asked questions about Core Web Vitals
What are Core Web Vitals?
They evaluate real users' loading, responsiveness, and visual stability using LCP, INP, and CLS. Assess the 75th percentile separately for mobile and desktop.
Does a PageSpeed Insights score of 100 mean Core Web Vitals are good?
They are different. The Lighthouse score is a lab result under configured conditions. Assess Core Web Vitals primarily using the CrUX real-user data at the top of PageSpeed Insights.
Is a difference between field and lab data a bug?
Not necessarily. Field data aggregates diverse devices, networks, regions, caches, and behavior over the past 28 days; a lab run uses one configuration. Use the difference to investigate device-specific and post-interaction issues.
Does no real-user data in PageSpeed Insights mean the page is good?
It means no good assessment has been made. The URL or origin may lack sufficient samples. Supplement with Lighthouse, Chrome DevTools, and your own RUM.
Can I stop measuring FID?
INP has replaced FID in Core Web Vitals. If older articles or dashboards use only FID, update them to INP and review interactions throughout the page visit.
Can a WordPress performance plugin alone fix the metrics?
It depends on the cause. Caching or lazy loading can help, but can also delay the LCP image, create JavaScript conflicts or layout problems, and interfere with analytics. Change one thing at a time in staging.
When will Core Web Vitals change after a fix?
Lab results can be checked immediately, but CrUX and PageSpeed Insights field data are rolling 28-day aggregates. Record the release date and review RUM and daily trends together.
Will good Core Web Vitals improve search rankings?
There is no guarantee. Core Web Vitals are part of page experience. Also address search intent, content quality, crawling and indexing, and internal links.
Summary: start with real-user data, isolate causes, and fix them one by one
Current Core Web Vitals are LCP, INP, and CLS. Start with field data from Search Console and PageSpeed Insights to find affected devices, URL groups, and metrics, then use DevTools and Lighthouse to identify elements, resources, and tasks.
Break LCP into response, discovery, download, and rendering; INP into input delay, processing, and presentation; and CLS into moved elements and their causes to clarify priorities. Implement changes individually and check functionality, accessibility, and analytics for regressions as well as speed.
Use lab measurements to check effects immediately, then track RUM and CrUX's 28-day window after release. Keep improving so people can read, interact, and achieve their goals, rather than optimizing for scores alone.