What Are Core Web Vitals? [And How to Improve Them]

Core Web Vitals are the three metrics Google uses to score how fast, responsive, and visually stable a page feels to a real visitor: Largest Contentful Paint (LCP), Interaction to Next Paint (INP), and Cumulative Layout Shift (CLS). Pass the "good" threshold on all three and your page clears the bar. Miss them and you frustrate users while handing competitors an edge in search.

Here is the short version. LCP measures how long the main content takes to appear. INP measures how quickly the page reacts when someone taps or clicks. CLS measures how much the layout shifts while everything loads. Google collects these scores from real Chrome users, then folds them into its page-experience signals for ranking.

The rest of this guide breaks down each metric, the exact score you want, why the numbers affect both SEO and revenue, and the changes that actually move them.

• Core Web Vitals are three metrics: LCP (loading), INP (responsiveness), and CLS (visual stability).
• The "good" targets are LCP under 2.5 seconds, INP under 200 milliseconds, and CLS under 0.1.
• Google scores your site from real users at the 75th percentile, so your slowest visitors count.
• The vitals feed into search ranking and directly affect conversions.
• Most fixes come down to image handling, JavaScript, and reserving space in your layout.

What Are Core Web Vitals?

Core Web Vitals are a set of three user-experience metrics that Google treats as part of its ranking signals. Each one measures a different part of how a page feels: speed of loading, speed of response, and stability of the layout.

Google grades every metric on a three-tier scale of Good, Needs Improvement, and Poor. It pulls the data from the Chrome User Experience Report, which records real sessions rather than lab tests. Your score reflects the 75th percentileof visits, so roughly a quarter of your users can still have a worse experience than your headline number suggests.

Here are the thresholds you are aiming for.

Largest Contentful Paint (LCP)

LCP marks the moment the largest visible element finishes rendering, usually a hero image, a headline, or a banner. It answers a simple question: how long before the visitor sees the thing they came for? A good LCP sits at 2.5 seconds or less.

Slow LCP almost always traces back to a few culprits: oversized images, a sluggish server, or render-blocking CSS and JavaScript that hold up the first paint.

To bring LCP down:

• Serve images in modern formats like WebP or AVIF, and compress them before upload.
• Preload the hero image so the browser fetches it early.
• Put static assets on a CDN to cut delivery time.
• Reduce server response time, often the quiet reason a fast-looking site still scores badly.
• Remove or defer CSS and JavaScript that block the first render.

Interaction to Next Paint (INP)

INP measures responsiveness. When a visitor taps a button, opens a menu, or adds a product to a cart, INP records how long the page takes to visually respond. It replaced First Input Delay as an official Core Web Vital because it captures the full span of an interaction, not only the first one. A good INP stays at or under 200 milliseconds.

Poor INP is usually a JavaScript problem. Heavy scripts tie up the main thread, so the browser cannot react until it finishes its current work.

To improve INP:

• Break long tasks into smaller chunks so the browser can respond between them.
• Defer or lazy-load scripts that are not needed for the first interaction.
• Trim third-party tags, since analytics and chat widgets often add the most delay.
• Keep event handlers lean and avoid running expensive work on every click.

Cumulative Layout Shift (CLS)

CLS measures visual stability. You have felt a bad CLS score yourself: you go to tap a link, an ad loads above it, the page jumps, and you tap the wrong thing. CLS adds up every unexpected shift during the page's life. A good score is 0.1 or lower.

Layout shift comes from elements that load without reserved space: images without dimensions, ads, embeds, and web fonts that swap in and reflow the text around them.

To reduce CLS:

• Set explicit width and height (or an aspect ratio) on every image and video.
• Reserve space for ads, banners, and embeds before they load.
• Avoid injecting content above what the visitor is already reading.
• Preload fonts and match fallback fonts closely to limit reflow on swap.

Layout stability starts with how the page is built, which is why it connects to how you plan a website structure in the first place.

Why Core Web Vitals Matter for SEO and Conversions

Two reasons: rankings and revenue.

On the SEO side, Google uses the vitals as a tiebreaker. When two pages match a query with similar relevance, the faster, more stable one tends to win the position. We covered this relationship in more detail in why website speed affects SEO.

On the revenue side, the numbers are hard to argue with. A Google-commissioned Deloitte study found that a 0.1 second improvement in load time raised retail conversion rates by 8.4% and increased average order value by 9.2%. Speed is not a vanity metric. It changes what people buy.

There is also an AI-search angle. Fast, well-structured pages are easier for crawlers and retrieval systems to process, which supports visibility as search shifts toward AI answers. That overlaps with the ideas in our guide to generative engine optimization.

How to Measure Core Web Vitals

You have two kinds of data, and you need both.

Field data comes from real users. Check the Core Web Vitals report in Google Search Console for a site-wide view, and PageSpeed Insights for real-user scores on a single URL. This is the data Google actually ranks on.

Lab data comes from a controlled test. Lighthouse (built into Chrome DevTools) and the lab section of PageSpeed Insights let you reproduce a load and debug it. Lab tools are for diagnosis. Field tools are for the truth.

A common trap is chasing a perfect Lighthouse score while your field data still fails. Trust the field numbers first, then use lab tools to find the cause.

Where Core Web Vitals Fit in a Real Build

Most Core Web Vitals problems are built in, not bolted on. A site running a heavy template with a dozen plugins fights its scores forever, because the weight is baked into the foundation. A custom, performance-first build avoids most of the problem before a single image is optimized.

That is the approach behind our web development work: lean code, modern image handling, and a structure that stays stable as it loads. If your current site keeps failing the vitals no matter how many tweaks you apply, the structure itself is usually the thing worth rebuilding. You can get in touch if you want a look at where yours stands.

Conclusion

Core Web Vitals turn "the site feels slow" into three numbers you can act on. Aim for LCP under 2.5 seconds, INP under 200 milliseconds, and CLS under 0.1, measured on real visitors. Fix the images, tame the JavaScript, and reserve space in your layout, and you improve rankings and conversions at the same time. For the bigger picture on how it all fits together, start with what web development actually involves.

Mihailo Dencev · SEO Analyst

SEO Analyst with experience in B2B SaaS and fintech SEO, specializing in content strategy, on-page optimization, keyword research, link building, and Generative Engine Optimization (GEO).

View full profile