A site with a PageSpeed score of 95 can be full of “poor” URLs in Search Console. The reverse also happens. That’s because what Google looks at isn’t a single lab test but the Core Web Vitals metrics that measure what real users experience: LCP, INP and CLS. Below we explain the three metrics, how they’re measured, the root causes we see most often in the field and improvement steps with measurable results.
The three metrics and good thresholds
| Metric | What does it measure? | Good | Weak |
|---|---|---|---|
| LCP – Largest Contentful Paint | The time it takes for the largest content in the visible area (usually the hero image or heading) to appear on screen | ≤ 2.5 s | > 4 s |
| INP – Interaction to Next Paint | The delay in responding to user interactions (clicks, taps, key presses) | ≤ 200 ms | > 500 ms |
| CLS – Cumulative Layout Shift | The amount of unexpected content shifting while the page loads | ≤ 0,1 | > 0,25 |
Assessment is based on the 75th percentile of page loads: if at least 75% of users have a good experience, the page is considered “good”. So a measurement on a fast office connection tells you nothing; what matters is the user coming in over a mobile network on a mid-range phone. INP replaced the First Input Delay (FID) metric in March 2024. FID only looked at the delay of the first interaction; INP takes all interactions on the page into account and is therefore much harder to pass.
Field data and lab data
Field data is the real experience collected from Chrome users (Chrome UX Report). The Core Web Vitals report in Search Console and the top section of PageSpeed Insights show this data, which is updated over a 28-day rolling window. A fix you make today appears gradually in the report over weeks.
Lab data is the measurement tools such as Lighthouse make under fixed device and network conditions. It’s used to diagnose a problem and see the effect of a change immediately. Because a lab test doesn’t interact, it doesn’t measure INP directly; Total Blocking Time (TBT) is looked at instead.
The right approach has three steps: find which page groups have problems using field data, diagnose the cause in the lab, and confirm the result with field data again. CrUX data may not exist for low-traffic pages. For your own real user monitoring (RUM), the web-vitals library can be connected to your analytics tool; this shows which template causes problems on which device group.
Improving LCP
LCP is examined by splitting it into four parts: server response time (TTFB), resource load delay, resource load duration and render delay. Optimization done without knowing which part is large is often spent in the wrong place. In the Performance panel of Chrome DevTools, the LCP element and the durations of these four parts are shown separately.
- TTFB: if it’s above web.dev’s guideline value of 0.8 seconds, getting LCP under 2.5 seconds becomes difficult. The fix is full-page caching, a CDN, and PHP-FPM and database improvements. An uncached WordPress page runs PHP and dozens of queries on every request; details are in the cache layers guide.
- LCP image: lazy loading should be disabled on the LCP image, it should be given
fetchpriority="high", and an appropriate size and modern format (WebP/AVIF) should be used. - Render-blocking resources: unnecessary CSS and synchronous JavaScript should be reduced and critical CSS prioritized.
- Fonts: self-hosted, subsetted and preloaded fonts;
font-display: swap.
LCP mistakes we see most often in the field
The first is setting the hero image as a CSS background. In page builders (including Elementor), the browser only discovers an image placed as a section background after the CSS has been downloaded and parsed. Resource load delay climbs to seconds. An image that’s an LCP candidate should, where possible, be a real <img> element.
The second is an optimization plugin applying lazy loading to all images. WordPress core tries to exempt the first images from lazy loading, but a plugin or theme can override this logic. If you see loading="lazy" on the LCP image in the source code, that’s where the problem is.
The third is a slider in the hero area. The first slide only becomes visible after JavaScript loads, and render delay grows. A single, static hero image is almost always faster.
Improving INP
INP is the time between a user’s click and the screen updating in response. If the main thread is busy with another JavaScript task at that moment, the click waits. Most of the problem is therefore the amount and timing of JavaScript.
- Inventory third-party tags (chat, ads, heatmaps); remove the unnecessary ones and defer the rest until after interaction.
- Find tasks longer than 50 ms (long tasks) in the browser performance profile and break them up.
- In event handlers, leave heavy work until after the visual update.
- Remove unused JavaScript loaded by page builders and plugins.
Breaking up a long task doesn’t mean doing less work; it means putting gaps in the work where the browser can update the screen. The visual response to a click (a menu opening, a button changing state) happens first, and sending analytics or heavy computation runs afterwards, yielding to the main thread with setTimeout or, in browsers that support it, scheduler.yield(). The user sees the response immediately. The rest can wait.
The most common source of poor INP in the field is tags added to the tag manager over the years that nobody owns. The campaign is over, the pixel remains. When a tag inventory is taken, the lines to remove usually become obvious. The second source is components such as mobile menus, tabs and accordions that force the whole DOM to be recalculated every time they open. A large DOM makes every interaction expensive.
Before cleaning up tags, record the current state: which tag runs on which page, with which trigger, and who owns it. Going through this list with the marketing team both speeds up removal decisions and prevents the “why was that tag deleted?” argument. A date and reason are written down for every tag removed.
Improving CLS
- Specify width and height (or aspect-ratio) on all image, video and iframe elements.
- Reserve space in advance for cookie banners, announcement bars and ad slots.
- Reduce text size changes caused by web fonts loading with font-matching settings.
- Don’t dynamically insert content above existing content.
A typical CLS trap is a cookie banner or campaign bar that loads late at the top of the page and pushes all the content down. If the banner opens in a fixed position (as an overlay), the layout doesn’t shift. Another is embedded videos and maps whose height is only determined after JavaScript loads; giving the container an aspect-ratio from the start removes the problem. Shifts within 500 ms after the user’s own interaction don’t count towards CLS; that’s why “opens on click” components are usually not a problem.
A measurable improvement process
- List the poor and needs-improvement URL groups in Search Console.
- For each group, take a lab measurement and performance profile on a representative page.
- Prioritize root causes by impact and cost.
- Measure the change in a test environment, then put it live.
- Monitor field data for 4 weeks and prepare a before-and-after table.
Search Console groups URLs by template. An error in a product page template affects hundreds of URLs together, and fixing it improves them all together. That’s why you should work at the template level, not page by page. Releasing each change separately also matters; if you put five changes live on the same day, you’ll never know which one worked.
Frequently asked questions
The Lighthouse score is low but Search Console shows “good”. Which should we believe?
Search Console shows real user (field) data and is the real indicator of user experience. Lighthouse is a lab test run under fixed conditions and is used for diagnosis. If field data is good, there’s no urgent problem; lab findings point to improvement opportunities.
Is converting images to WebP enough?
Not on its own. The LCP image also needs the right size, priority (fetchpriority=”high”), exemption from lazy loading and a fast server response. Width and height should also be specified on all images.
What hurts INP the most?
Long JavaScript tasks: heavy third-party tags, large framework bundles and event handlers that do a lot of work on a single click. Removing unnecessary scripts and breaking long work into pieces are the most effective fixes.
The effect of performance on rankings is limited; Google states that it takes page experience into account but that relevance is far more decisive. The real gain is user experience and conversions. To measure and improve your site, see our web performance and Core Web Vitals service.