Websites

Core Web Vitals (LCP, INP, CLS): How to Speed Up Your Website

9 min read Updated: Czytaj po polsku
Core Web Vitals (LCP, INP, CLS): How to Speed Up Your Website

Core Web Vitals are three Google metrics for user experience: LCP (how fast the main content loads – good is 2.5 s or less), INP (how quickly the page responds to input – 200 ms or less) and CLS (visual stability – 0.1 or less). They are assessed at the 75th percentile of real visits, separately for mobile and desktop. To speed up your site, start with field data in Search Console, find the metric that is failing – usually LCP on mobile – and fix it at template level rather than page by page.

What are Core Web Vitals?

Core Web Vitals are the subset of Web Vitals that Google considers essential for every page. Each covers a different part of the experience: loading, interactivity and visual stability. Results are assessed at the 75th percentile – a page passes a metric if at least three out of four visits fall within the threshold, separately on mobile and desktop (web.dev).

Metric What it measures Good Needs improvement Poor
LCP (Largest Contentful Paint) Time until the largest image or text block in the viewport is rendered ≤ 2.5 s 2.5–4 s > 4 s
INP (Interaction to Next Paint) Time from a click, tap or key press to the next frame; the longest interaction counts, ignoring outliers ≤ 200 ms 200–500 ms > 500 ms
CLS (Cumulative Layout Shift) Total of unexpected layout shifts in the worst “session window” (max 5 s) ≤ 0.1 0.1–0.25 > 0.25

INP replaced the older FID metric on 12 March 2024. It is a big shift: FID measured only the delay of the first interaction, whereas INP observes every click, tap and key press throughout the visit. Scrolling and hovering are not counted.

Do Core Web Vitals affect Google rankings?

Google does not disclose how much weight they carry. Its Search Central documentation says good Core Web Vitals, along with other page experience aspects, align with what its core ranking systems seek to reward, and it explicitly recommends that site owners achieve them.

In practice, treat CWV as a hygiene factor rather than a lever that will push weak content to the top. A fast page that misses the searcher’s intent will not beat a slower but clearly more helpful one. Speed also matters beyond rankings: a slow page loses visitors whose clicks you may already have paid for in ads.

How do you check your Core Web Vitals?

First, distinguish between two kinds of data. Field data comes from real Chrome users and is what the assessment is based on. Lab data is a simulated single load on a defined device – great for diagnosis, but it is not the result Google sees.

Tool Data type What it is for
Core Web Vitals report in Search Console Field (CrUX) Groups of similar URLs with problems; validating fixes
PageSpeed Insights Field and lab Quick overview of a single URL and the whole origin
Chrome DevTools (Performance panel) Lab, compared against field data Diagnosis: what delays LCP, which interactions are slow, what shifts the layout
Lighthouse Lab Technical audit; cannot measure INP, so it shows TBT instead
CrUX (Chrome UX Report) Field Historical results and origin comparisons

The Search Console report groups URLs with a similar user experience, and a group’s status is set by its slowest metric: poor CLS with LCP that needs improvement means the group is “poor”. If a group lacks enough data, its URLs may be left out of the report. On low-traffic sites you are then left with lab data and your own real-user monitoring (RUM).

How do you improve LCP?

LCP is the most common problem. According to the Web Almanac 2025 (July 2025 data), 62% of sites have good LCP on phones, compared with 77% for INP and 81% for CLS. On 73% of mobile pages the LCP element is an image, as web.dev’s round-up reports, so start there.

Break LCP into its four parts

LCP subpart What it covers Recommended share
TTFB Time to the first byte of HTML from the server ~40%
Resource load delay Time from TTFB until the LCP image starts downloading under 10%
Resource load duration Downloading the image itself ~40%
Element render delay Time from download to the element appearing on screen under 10%

These proportions come from web.dev’s guide to optimising LCP and are guidelines, not hard rules. If resource load delay is eating a whole second, the problem is not the image’s file size – it is that the browser finds out about the image too late.

What to do, step by step

  1. Put the LCP image in the HTML as an <img> with src or srcset. According to web.dev, 35% of LCP images had URLs that were not discoverable in the initial HTML, and 7% of pages hide them in a data-src attribute – typical of lazy-loading plugins.
  2. Add fetchpriority="high" to the LCP image. Only 15% of eligible pages do this. Do not give high priority to more than one or two images, or the effect gets diluted.
  3. Never lazy-load the LCP image. Remove loading="lazy" from the hero image.
  4. Make the image smaller: correct dimensions, AVIF or WebP, compression, delivery via a CDN.
  5. Cut TTFB: page caching, a CDN, fewer redirects. Only 33% of HTML documents are served from a CDN.
  6. Remove render-blocking resources: synchronous scripts in the <head> and unnecessary CSS. Render content on the server rather than waiting for JavaScript.
  7. Configure web fonts with a font-display value other than auto or block, so text does not wait for the font file.

Be wary of hero carousels. An image that only appears once the slider script runs is, by definition, discovered late.

How do you improve INP?

Every interaction has three phases (web.dev): input delay – the time before event handlers start running; processing duration – running the code; and presentation delay – the time until the next frame is painted. The usual culprit is a busy main thread.

  • Break up long tasks. Any task over 50 ms blocks the thread. scheduler.yield() lets you hand control back to the browser mid-task – it works in Chrome and Edge 129+ and Firefox 142+, but not in Safari, so you need a fallback such as setTimeout.
  • Ship less JavaScript. Find unused code with the Coverage tab in DevTools, split bundles, and audit your Google Tag Manager container – old pixels and finished experiments tend to linger for years.
  • Reduce rendering cost. Keep the DOM small, avoid forced layouts in loops, and apply content-visibility to off-screen sections.
  • Trim third-party scripts. Load chat, social widgets, maps and video players only after interaction, using a lightweight “facade” until then.
  • Give instant feedback. Update the button’s appearance first and do the heavy lifting after the next frame is painted.

Lighthouse cannot measure INP because it does not perform real interactions – it reports TBT as a proxy. To diagnose slow interactions, use the DevTools Performance panel while clicking through the page as a user would, or rely on field data.

How do you fix CLS?

According to web.dev, the typical causes are images and videos without dimensions, web fonts that render larger or smaller than their fallbacks, ads and widgets that resize after loading, and content injected above existing content. Shifts within 500 ms of a click or key press are excluded, because the user expects them.

  • Set dimensions. Use width and height attributes or aspect-ratio for images and video. 66% of pages have at least one unsized image.
  • Reserve space (min-height) for ads, embeds and anything loaded asynchronously.
  • Show cookie banners and promo bars as overlays instead of injecting them above the content.
  • Animate transform and opacity, not top, left or margin. Pages that animate layout-affecting properties are 15% less likely to have good CLS.
  • Keep pages bfcache-eligible. A Cache-Control: no-store header and unload listeners disable the instant back/forward restore that eliminates shifts.
  • Pick a fallback font with similar metrics, so swapping fonts does not reflow the text.

A step-by-step plan for fixing Core Web Vitals

  1. Open the Core Web Vitals report in Search Console and start with mobile. Note which metric and which URL groups are rated “poor”.
  2. Pick a representative URL from each group and run it through PageSpeed Insights. Field data shows the scale of the problem; lab data hints at the cause.
  3. Diagnose in Chrome DevTools: the LCP breakdown, long tasks, sources of layout shifts.
  4. Fix at template level. One change to a post or product template improves hundreds of URLs at once.
  5. Deploy and start validation in Search Console. Google then runs a 28-day monitoring session – field data does not change overnight.
  6. Set a performance budget, such as a maximum JavaScript size and hero image weight, and check it on every release so the problem does not creep back.

Core Web Vitals are only one part of technical SEO. For the full checklist, see our step-by-step SEO audit checklist.

The most common problems on WordPress sites

WordPress sites and page builders tend to repeat the same patterns:

  • a heavy page builder loading its own scripts and styles on every page,
  • a hero slider instead of a single, optimised image,
  • a lazy-loading plugin that also catches the LCP image,
  • dozens of plugins, each adding JavaScript and CSS site-wide,
  • multiple font families and weights pulled from a third-party server,
  • photos uploaded straight from a camera or phone without resizing,
  • chat widgets and YouTube embeds that load immediately,
  • no page caching and cheap hosting with a long TTFB.

It is easier to design a new site for speed from day one than to rescue it after launch. That is how we approach website design and development and e-commerce builds, where one slow product template is repeated across thousands of URLs. If you are planning rich animation or 3D graphics, read how to balance them with performance in our article on 3D websites built with WebGL.

Is your site failing Core Web Vitals? We will find what is slowing it down and fix the causes, not the symptoms, as part of our SEO and GEO service. Get in touch and send us your URL.

Frequently asked questions

What are good Core Web Vitals scores?

Good means LCP of 2.5 s or less, INP of 200 ms or less and CLS of 0.1 or less, measured at the 75th percentile of visits, separately for mobile and desktop. Poor starts above 4 s for LCP, 500 ms for INP and 0.25 for CLS. Anything in between needs improvement.

What is the difference between INP and FID?

FID measured only the delay of the first interaction on a page. INP observes every click, tap and key press during a visit and covers the whole time until the next frame is painted, not just the initial delay. INP replaced FID as a Core Web Vital on 12 March 2024.

Why does PageSpeed Insights show a different result from Search Console?

The 0–100 score in PageSpeed Insights is a lab test of one simulated page load. Search Console shows only field data from real users, aggregated for groups of similar URLs. The Core Web Vitals assessment is based on field data, so that is the data that matters more.

How long until Core Web Vitals fixes show up?

Field data comes from real visits, so changes do not appear immediately. Once you start validation, Search Console runs a 28-day monitoring session. Meanwhile, you can track progress in PageSpeed Insights or with your own real-user monitoring.

Are Core Web Vitals a Google ranking factor?

Google recommends good Core Web Vitals and says they align with what its core ranking systems seek to reward, but it does not disclose how much weight they carry. Speed will not replace relevant, helpful content. Treat CWV as a baseline for a good site, not a shortcut to the top spot.

Why does Lighthouse not show INP?

Lighthouse loads the page without real user interactions, so it cannot measure INP. It reports Total Blocking Time (TBT) as a proxy instead. You can diagnose slow interactions in the Chrome DevTools Performance panel or from field data.

Sources

  1. web.dev – Web Vitals
  2. web.dev – Largest Contentful Paint (LCP)
  3. web.dev – Interaction to Next Paint (INP)
  4. web.dev – Cumulative Layout Shift (CLS)
  5. web.dev – Interaction to Next Paint becomes a Core Web Vital on March 12
  6. web.dev – Optimize Largest Contentful Paint
  7. web.dev – The most effective ways to improve Core Web Vitals
  8. HTTP Archive – Web Almanac 2025: Performance
  9. Google Search Central – Understanding Core Web Vitals and Google search results
  10. Search Console Help – Core Web Vitals report

Need help with this?

We design and code company websites from scratch — no off-the-shelf templates, built for conversion, speed and visibility in Google and AI search.