SEO & Technology

Improving Core Web Vitals: LCP, INP and CLS

Core Web Vitals are three metrics Google uses to assess the user experience of a page: LCP measures how quickly the main content becomes visible, INP how quickly the page responds to a click or tap, and CLS how stable the layout remains while it loads. You improve them by first measuring with data from real visitors, and then tackling the biggest cause for each metric.

At a glance

What are Core Web Vitals? The short answer

A page can technically be ‘loaded’ and still feel slow: the text is there, but the image at the top arrives later, a button does not respond straight away, or the content jumps just as you are about to tap. Core Web Vitals make that experience measurable with three numbers.

Google assesses them on the basis of real visits, not a single test. A page meets the standard when at least 75% of visits have a good value, measured separately for mobile and desktop.

Good values are not a goal in themselves. They indicate that visitors can use your page smoothly. That helps your conversion rate, and it is one of the signals Google takes into account.

Core Web Vitals – the three metrics LCP, INP and CLS

Standards

LCP, INP and CLS: what do they mean and what counts as good?

The thresholds are set by Google and apply to every website. You can find them in the documentation at web.dev on Web Vitals.

Core Web Vitals thresholds
MetricWhat it measuresGoodNeeds improvementPoor
LCP (Largest Contentful Paint)How long it takes for the largest element in view to load2.5 seconds or lessBetween 2.5 and 4 secondsMore than 4 seconds
INP (Interaction to Next Paint)How long the page takes to respond visibly to an interaction200 milliseconds or lessBetween 200 and 500 millisecondsMore than 500 milliseconds
CLS (Cumulative Layout Shift)How much the content shifts unexpectedly0.1 or lessBetween 0.1 and 0.25More than 0.25

In March 2024, INP replaced the earlier metric FID (First Input Delay). Whereas FID only measured the first interaction, INP looks at all interactions during a visit. Older articles and tools that still refer to FID are outdated on that point.

Measure

How do you measure Core Web Vitals reliably?

There are two types of data, and they tell you different things. Mix them up and you end up solving the wrong problem.

Real visitors

Field data

Measurements from real visits in Chrome, collected over the past 28 days. This is the data Google uses to assess your page. You can find it in the Core Web Vitals report in Search Console and at the top of PageSpeed Insights.

A single simulated test

Lab data

A test on one device with a fixed connection, such as Lighthouse. Useful for finding causes and checking a change straight away. A lab test does not measure INP, because no real user is clicking.

So the order is: field data to know whether there is a problem and on which pages, then lab data to find where it comes from. If a website has too few visitors, there is no field data and you have to rely on lab tests.

LCP

How do you improve LCP?

On most pages, the LCP element is the large image or the heading at the top. Anything that slows down its loading counts: the server, the styles, the scripts and the image itself.

Start by identifying which element it is. PageSpeed Insights and Chrome’s developer tools show you.

  • Speed up the server response. Page caching, sufficient server capacity and as few heavy database queries per request as possible.
  • Make the image lightweight. The right dimensions for the screen and a modern format such as WebP or AVIF.
  • Do not lazy-load the main image. loading="lazy" belongs on images below the fold, not on the image at the top.
  • Give it priority. With fetchpriority="high", the browser knows this image needs to come first.
  • Do not block rendering. Styles and scripts that the page does not need straight away can be loaded later.
  • Load fonts smartly. Self-hosted fonts, only the weights you use, and text that is already visible before the font has arrived.
Loading the main image with priority
<img src="/beelden/hero.avif" width="1200" height="630"
     fetchpriority="high" alt="Beschrijving van het beeld">

INP

How do you improve INP?

INP is almost always about JavaScript. As long as the browser is busy executing a script, it cannot respond to a click. The more code runs, the longer the visitor waits.

  • Load less JavaScript Every script you leave out does not need to be downloaded, processed and executed.
  • Be strict with third-party scripts Chat widgets, trackers, video players and ads are often the heaviest items. Load them only when they are needed.
  • Break up long tasks Split work that keeps the browser busy for a long time into smaller chunks, so it can respond in between.
  • Give feedback first Show immediately that the click has been registered, and do the heavy work afterwards.
  • Keep the page simple The more elements a page contains, the more work every visual change requires.
  • Limit what happens during loading Sliders, animations and pop-ups that all start at the same time compete with the visitor’s first tap.

CLS

How do you improve CLS?

Layout shifts happen when something takes up space the browser had not anticipated. The solution is always the same: reserve the space before the content arrives.

  • Give images and videos dimensions. With a width and a height in the HTML, the browser knows how much space to keep free.
  • Reserve space for embedded content. Maps, videos, ads and third-party forms get a fixed height.
  • Do not insert anything above existing content. A cookie banner or notification bar that pushes the page down counts as a shift. Overlay it instead.
  • Prevent text from jumping when fonts load. Choose a fallback font with similar dimensions, so the text does not reflow when the real font loads.
  • Animate with transform. Animations that change the position or size of elements in the layout cause shifts; transform does not.
Dimensions on an image
<!-- Breedte en hoogte reserveren de ruimte vóór het beeld geladen is -->
<img src="/beelden/team.webp" width="800" height="533" loading="lazy" alt="Het team">

Platform

Core Web Vitals in WordPress and in Next.js

The metrics are the same everywhere; the causes differ by platform. Neither is fast or slow by default: it depends on how the website is built.

Theme, plugins and hosting

WordPress

  • A heavy theme or a page builder that loads lots of styles and scripts on every page.
  • Plugins that load their code everywhere, even where they do nothing.
  • Images uploaded at a larger size than they are displayed.
  • No page cache, or hosting that responds slowly.
  • Sliders and animations above the fold.

JavaScript and hydration

Next.js

  • Too much code sent to the browser, where the server could have done the work.
  • Hydration that keeps the page busy just when the visitor wants to click.
  • Images without the image component, and therefore without dimensions and suitable formats.
  • Fonts and third-party scripts loaded outside the built-in optimisation.
  • Pages rebuilt on every request when they could have been static.

In WordPress, the gains often come from leaving things out and from good maintenance. In Next.js, they often come from choosing what happens on the server and what happens in the browser. How I approach this when building a website is explained under WordPress specialist and React and Next.js.

Nuance

Do you need a score of 100?

No. The 0 to 100 score in PageSpeed Insights is a lab score from a single simulated test. It is useful as a pointer, but it is not what Google uses to assess your page. That is the field data: the three Core Web Vitals for real visitors.

So a page can score 70 in the test and still meet all three standards for real visitors. The reverse also happens. The goal is ‘good’ for LCP, INP and CLS in the field data, not a perfect number in a test.

Nor should you expect a jump in the search results from speed alone. Google takes page experience into account, but relevance remains decisive: a fast page that does not answer the question will not beat a slightly slower one that does. Where speed almost always makes a direct difference is with your visitors: people who do not have to wait are less likely to leave.

Approach

In what order should you tackle it?

Improving speed without a plan often ends with installing yet another plugin. This order keeps the work focused.

01

Look at the field data

Which metric is falling short, on mobile or desktop, and on which group of pages?

02

Pick the worst page type

Pages with the same template share the same cause. Fix it in the template, not page by page.

03

Find the biggest cause

One lab test per page type usually reveals the one or two items that weigh most heavily.

04

Make the change and test again

Use a lab test to check whether the change does what you expect, and that nothing else got worse.

05

Wait for new field data

Field data covers 28 days. It therefore takes a few weeks before an improvement is fully visible.

06

Keep it in good shape

Any new plugin, tracker or slider can undo the result. Measure again after every major change. For a WordPress website, that is part of WordPress maintenance.

FAQ

Frequently asked questions about Core Web Vitals

LCP stands for Largest Contentful Paint: the moment the largest visible element on the page, usually an image or a heading, has loaded. Google considers 2.5 seconds or less to be good.

INP stands for Interaction to Next Paint. It measures how long it takes for the page to respond visibly after a visitor clicks, taps or types. 200 milliseconds or less is good.

CLS stands for Cumulative Layout Shift: the extent to which content shifts unexpectedly while the page loads or is being used. A value of 0.1 or less is good.

Enter the address in Google’s PageSpeed Insights. At the top, you will see the field data from real visitors, if available, and below that a lab test. For the website as a whole, look at the Core Web Vitals report in Search Console.

For how visitors experience your website: the field data in Search Console and PageSpeed Insights. For finding causes: a lab test such as Lighthouse. Never compare the lab scores of two different tools with each other.

They are part of the page experience signals that Google takes into account. The effect is limited compared with relevance and content. A good score does not guarantee a better position, but a poor experience does cost you visitors.

First measure which of the three metrics is the problem. For LCP: a faster server and a lighter main image. For INP: less JavaScript. For CLS: dimensions on images and fixed space for embedded content.

More on this topic

Further reading

The related service

Technical SEO as a service

Are your pages failing to meet the standards, or are you unsure where the delay comes from? The service page explains how I investigate performance and fix it in the code, in WordPress and in Next.js.

Dries Nijs, Organic Web Specialist and author of this article

About the author

Dries Nijs, Organic Web Specialist

I am Dries Nijs, a developer and SEO consultant from Maasmechelen. I tackle performance where it originates: in a website’s templates, scripts and server set-up. MadeByDries is the personal brand under which I work.

Are your pages missing the standards?

Send me your website’s address. Then we can look at which metric is falling short and where the cause lies.

Discuss your project

Tell me what you want to build or improve

You do not need a technical brief yet. Tell me where you are now and what you want to achieve, and I will help you find the right approach.

Choose at least one topic. You can select more than one.

I only use your details to respond to your enquiry.

Prefer to email me directly?

Location
Maasmechelen, Belgium