Improve Core Web Vitals: A Guide to LCP, INP and CLS
How to improve Core Web Vitals step by step: read field data, break LCP into subparts, split long tasks for INP and bring CLS close to zero.
Improving Core Web Vitals means bringing a page’s loading speed (LCP), interaction responsiveness (INP) and visual stability (CLS) below the good threshold for most of its real users. The right order is this: first use field data to find which metric and which template have the problem, then break that metric into its subparts and fix the largest one. Following this order, instead of installing a random “speed plugin”, saves time and produces lasting results.
I explained what Core Web Vitals are and where they sit within technical SEO in my post what is technical SEO. This post focuses on implementation: I walk through which tool to open for what, which code change fixes each metric and how to verify the fix, step by step.
What are the Core Web Vitals thresholds?
The good experience thresholds in Core Web Vitals are 2.5 seconds for LCP, 200 milliseconds for INP and 0.1 for CLS.[2] Google recommends assessing these values at the 75th percentile of page loads, segmented across mobile and desktop.[2] In other words, for a page to count as “good”, all three metrics need to stay below the threshold in at least 75 percent of visits.
- LCP: largest content appears
- ≤ 2.5 s
- INP: visual response to interaction
- ≤ 200 ms
- CLS: unexpected layout shift
- ≤ 0.1
The three metrics answer different questions. LCP (Largest Contentful Paint) measures how long the main content takes to appear. INP (Interaction to Next Paint) measures how quickly the page visually responds to a user’s click. CLS (Cumulative Layout Shift) scores how much elements move unexpectedly.
INP replaced First Input Delay (FID) on March 12, 2024. Google announced the change in a web.dev announcement. FID only looked at the waiting time of the first interaction. INP looks at interactions across the whole page lifetime, which makes it a much tougher metric on sites with heavy JavaScript.
Do Core Web Vitals affect rankings?
According to Google’s Search Central documentation, good Core Web Vitals, along with other page experience aspects, align with what its core ranking systems seek to reward.[1] The same documentation also makes clear that ranking looks at relevance first. That is why I see Core Web Vitals not as a ranking lever but as an obstacle in front of good content. A page that loads slowly loses the visitor from the search result in the first few seconds.
How are Core Web Vitals measured: field data or lab data?
Core Web Vitals are measured with two kinds of data: field data collected from real users and lab data taken in a controlled environment. Google’s assessment and the Search Console report are based on field data. Lab data is used to find the cause of a problem and to test a fix immediately.
Field data
- Comes from real Chrome users (CrUX)
- Search Console and the top of PageSpeed Insights
- This is the basis of Google assessment
- Changes take weeks to show up
- Does not answer the why question
Lab data
- Taken on one device over a simulated connection
- Lighthouse and Chrome DevTools
- Meant for diagnosis and retesting
- Changes are measured instantly
- Cannot measure INP without real interaction
Lab tools have a limit. Tools like Lighthouse that run in a simulated environment without a user cannot measure INP, because there is no real user interaction.[2] In these tools, the closest signal to INP is Total Blocking Time (TBT), the total time the main thread stays blocked.
I always start measuring from the Core Web Vitals report in Search Console. The report shows URLs in groups of similar pages. This grouping is very useful, because a problem in one group usually comes from the same template. I covered how to read the report in my post how to use Google Search Console. Then I open a sample URL from the problem group in PageSpeed Insights and look at field data and the lab diagnosis side by side.
How do you improve LCP?
LCP measures when the largest image or text block appears during the first load of a page, and it is the sum of four subparts. Google’s web.dev guide defines these parts as time to first byte (TTFB), resource load delay, resource load duration and element render delay.[3] LCP should be read not as a single number but as the distribution of these four parts. The LCP insight in the Performance panel of Chrome DevTools shows this breakdown directly.
| Subpart | What does it measure? | Typical fix |
|---|---|---|
| Time to first byte (TTFB) | The server sending the first byte of HTML | CDN, caching, shorter server-side render time |
| Resource load delay | The LCP image request starting after HTML arrives | Make the image discoverable in HTML, fetchpriority="high" |
| Resource load duration | Downloading the LCP image | WebP or AVIF, correct size, srcset |
| Element render delay | Painting the downloaded image on screen | Reduce render-blocking CSS and JavaScript |
The most common mistake I see is giving the LCP image lazy loading. The web.dev guide forbids this explicitly: lazy-loading the LCP image always creates an unnecessary resource load delay.[3] The second common mistake is adding the hero image as a CSS background or with JavaScript. In that case, the browser cannot discover the image while reading the HTML and starts the request late.
<!-- LCP image: in the HTML, not lazy-loaded, high priority and sized -->
<img
src="/img/hero-800.avif"
srcset="/img/hero-480.avif 480w, /img/hero-800.avif 800w, /img/hero-1200.avif 1200w"
sizes="(max-width: 600px) 100vw, 800px"
width="800" height="450"
fetchpriority="high"
alt="Wide-angle photo of a clinic waiting room">
In this example, the image is in the HTML, so it is discovered immediately. The fetchpriority="high" attribute tells the browser that this request should come before other images.[5] The width and height attributes protect CLS at the same time. You can keep lazy-loading the below-the-fold images on the rest of the page.
If TTFB is high, the problem is not on the front end but on the server. On dynamic pages that hit the database on every request, a full-page cache and a CDN usually give the biggest gain. On this site I use static generation with Astro and Cloudflare Pages; because the HTML is already built, most of the TTFB is just network distance.
How do you improve INP?
INP is the sum of three phases of an interaction: input delay, processing duration and presentation delay.[4] Input delay happens when the main thread is busy with other work as the user clicks. Processing duration is the time event listeners take to run. Presentation delay is the time the browser needs to paint the result on screen.
The common enemy of all three phases is long tasks. According to web.dev, any task that runs longer than 50 milliseconds counts as a long task.[5] While a long task runs, the browser cannot respond to the user’s click. That is why the main way to improve INP is to break long tasks into small pieces and give the main thread room to breathe often.
// Split heavy work into chunks and yield to the main thread in between
async function yieldToMain() {
if (globalThis.scheduler?.yield) return scheduler.yield();
return new Promise((resolve) => setTimeout(resolve, 0));
}
button.addEventListener('click', async () => {
showLoadingState(); // 1. Immediate visual feedback for the user
await yieldToMain(); // 2. Let the browser paint the next frame
await sendAnalytics(); // 3. Defer non-urgent work
});
In this pattern, the user sees the visual response first, and non-urgent work such as analytics runs afterwards. In browsers that support scheduler.yield(), it yields to the main thread without the task losing its place in the queue.[5] In browsers that do not, setTimeout gives roughly the same effect.
Before this code-level fix, there is a simpler step: remove unnecessary JavaScript. Unused pixels, old A/B test scripts, chat widgets and duplicate analytics tags make INP worse directly. The Coverage panel in Chrome DevTools shows code that is loaded but never runs. Asking “does this data still feed a decision?” for every tag in the tag manager is often the fastest win.
How do you reduce CLS?
CLS scores elements on a page that move without the user expecting it, and it almost always comes from content without reserved space. The most common cause is images with no width and height values. web.dev recommends always adding size attributes to images and videos or reserving space with CSS aspect-ratio; the details are in its CLS optimization guide.
The other common causes are as follows. A cookie banner, campaign strip or ad slot loaded later pushes content down. When a web font arrives late, lines of text reflow. Animations made with layout-affecting CSS properties such as top or height also cause shifts; you should use transform instead.[5]
The cookie consent banner matters especially for sites in Turkey. Because of KVKK (Turkey’s personal data protection law) and GDPR, almost every site has a consent banner, and most of them are injected at the top of the page later. Showing the banner as a fixed-position (position: fixed) layer, instead of one that pushes content, protects CLS. I explained how the consent banner relates to measurement in my post what is Consent Mode v2.
Finally, check the back/forward cache (bfcache). The bfcache restores a page instantly from memory when the user presses the back button, instead of reloading it. According to web.dev, common reasons pages are not eligible for the bfcache are the no-store caching directive and unload event listeners.[5]
What order should Core Web Vitals improvements follow?
Short answer
How do you improve Core Web Vitals?
Core Web Vitals are improved by finding the failing metric and template in field data and breaking that metric into its subparts. First identify the poor URL groups in Search Console. Then inspect a sample URL with PageSpeed Insights and DevTools, fix the largest subpart in the template and confirm the result in field data.
- Find the URL groups in poor status in the Core Web Vitals report in Search Console.
- Open a sample URL from each group in PageSpeed Insights and confirm the failing metric.
- Break the metric into subparts: four subparts for LCP, three phases for INP.
- Fix the largest subpart at the template level.
- Test the change in the lab with Lighthouse and DevTools.
- After release, start validation in Search Console and watch the field data.
The most important part of this order is thinking at the template level. On an e-commerce site, category, product and blog pages usually come from three separate templates. A single image mistake in the product template drops thousands of URLs into the poor group at once. In the same way, a single fix improves all of them together.
- Group
Match the URL groups in the Search Console report to templates: home page, category, product, service, blog.
- Prioritize
Start with the template that holds the most URLs and the highest organic traffic.
- Diagnose
Look at LCP subparts and long tasks in a DevTools Performance recording.
- Fix and measure
Ship the change on one template first and compare the lab measurement with the previous one.
- Validate
Validate the fix in Search Console and watch the field data change over a few weeks.
I apply the same method to landing pages that receive ad traffic. A paid click is lost more expensively than an organic click on a page that loads slowly. That is why I audit third-party tags and the hero image separately on campaign pages. On the e-commerce side, you can use these checks together with my e-commerce SEO checklist.
Conclusion
Improving Core Web Vitals is not about chasing a score but about reducing the delay real users experience. Find the failing template in field data, break the metric into subparts and fix the largest part at the code level. For LCP, make the image discoverable early and prioritize it. For INP, break up long tasks and remove unnecessary JavaScript. For CLS, reserve space for every element in advance.
As a next step, open the Core Web Vitals report in Search Console and note the poor group with the most URLs on mobile. If you want to address your technical foundation end to end, you can see how I work on my SEO services page and read about my software background on the about page.
Key terms
- LCP
- LCP (Largest Contentful Paint) is a Core Web Vitals metric that measures when the largest image or text block in the viewport appears on screen. According to Google, LCP should occur within 2.5 seconds of when the page first starts loading for a good experience.
- INP
- INP (Interaction to Next Paint) is a Core Web Vitals metric that measures how quickly a page visually responds to a user's clicks, taps and keyboard interactions. It reports one of the slowest interactions observed over the page lifetime; 200 milliseconds or less is considered good.
- CLS
- CLS (Cumulative Layout Shift) is a Core Web Vitals metric that scores unexpected movement of elements while a page loads or is being used. Images without dimensions and components injected later are the main causes; a score below 0.1 is considered good.
- CrUX
- CrUX (Chrome User Experience Report) is a public dataset collected from the real page experiences of Chrome users that supplies Core Web Vitals field data. The field data sections in Search Console and PageSpeed Insights are based on this source.
- Long task
- A long task is a JavaScript or rendering job that keeps the browser's main thread busy for more than 50 milliseconds. While a long task runs, the browser cannot respond to user input, which makes long tasks the main factor behind poor INP.
Frequently asked questions
Does improving Core Web Vitals boost rankings?
Google says good Core Web Vitals align with what its core ranking systems seek to reward. Relevance always comes first, though; weak content does not rise on speed alone. A fast page makes a difference among pages of similar quality and in how users behave.
Why does Search Console say poor when my Lighthouse score is high?
Lighthouse is a lab measurement taken on one device over a simulated connection. Search Console shows real field data collected from Chrome users. Slow phones, weak mobile networks and real interactions do not show up in a lab test, so the two results can differ.
Why did INP replace FID?
FID only measured the input delay of the first interaction. INP looks at the response time of clicks, taps and keyboard interactions across the whole page lifetime. Google made INP a Core Web Vitals metric in place of FID on March 12, 2024.
How long until a Core Web Vitals fix shows up?
The Core Web Vitals report in Search Console is based on a rolling window of real user data. So after a fix goes live, the improvement appears gradually in the report and can take a few weeks. In lab tools, the effect can be measured right away.
Which Core Web Vitals metric should I start with?
Starting with the poor metric that affects the most URLs in Search Console is the most efficient path. On most sites, that is mobile LCP or INP broken by third-party tags. Because the problem usually lives in a template, a single fix improves hundreds of URLs together.
Sources
The full topic: Technical SEO guide ↗