Introduction
Core Web Vitals are the three numbers Google uses to describe how a page actually feels to a real visitor: how fast the main content appears, how quickly the page responds to a tap or click, and how much the layout jumps around while it loads. They became a ranking signal in 2021, and they are measured from real Chrome usage data rather than from a lab test.
That distinction matters. A page can score 99 in Lighthouse on a fast office connection and still fail Core Web Vitals for visitors on a mid-range Android phone over mobile data, because the field data comes from those visitors, not from the test machine.
This guide explains each metric, the exact thresholds, the causes that show up most often, and the order to fix them in. It includes copy-ready code, a measurement workflow and a before-and-after check you can use to prove the improvement.
What Core Web Vitals Are
Core Web Vitals are a subset of Google's page experience signals. They are reported in three states — good, needs improvement and poor — using the 75th percentile of real user sessions. In plain terms, a page passes when three out of four visits meet the threshold, not when the average does.
| Metric | Measures | Good | Needs improvement | Poor |
|---|---|---|---|---|
| LCP — Largest Contentful Paint | Loading speed of the main content | 2.5 s or less | 2.5 s to 4.0 s | Over 4.0 s |
| INP — Interaction to Next Paint | Responsiveness to taps and clicks | 200 ms or less | 200 ms to 500 ms | Over 500 ms |
| CLS — Cumulative Layout Shift | Visual stability during load | 0.1 or less | 0.1 to 0.25 | Over 0.25 |
The 75th percentile rule is why one slow template can fail an entire site group. If a shared header loads a heavy script on every page, every page inherits the same delay, and the group is judged on the slowest quarter of visits.
Why Field Data and Lab Data Disagree
Two different measurements describe the same page, and they rarely agree.
| Source | What it measures | Strength | Weakness |
|---|---|---|---|
| Field data (CrUX, Search Console) | Real visitors on real devices | Reflects what users experience | Lags by up to 28 days |
| Lab data (Lighthouse, PageSpeed Insights) | A simulated run on a fixed profile | Reproducible, gives specific fixes | Cannot see real device or network mix |
Use field data to decide whether to act, and lab data to decide what to change. Acting on lab data alone chases scores; acting on field data alone leaves you without a diagnosis.
Largest Contentful Paint (LCP)
LCP records when the largest visible element in the viewport finishes rendering. That element is usually a hero image, a large heading, a video poster or a background image block. It is a loading metric, and it is the one most sites fail.
LCP breaks into four phases, and the slowest phase tells you which fix applies.
| Phase | What happens | Typical fix |
|---|---|---|
| Time to first byte | Server responds | Caching, faster hosting, CDN |
| Resource load delay | Browser waits before fetching the hero | Preload the image, remove render-blocking CSS |
| Resource load time | The hero downloads | Compress, resize, serve WebP or AVIF |
| Element render delay | Browser paints after download | Remove blocking scripts, defer fonts |
Common LCP Causes
| Cause | How to recognise it | Fix |
|---|---|---|
| Oversized hero image | A 2 MB JPEG above the fold | Compress and resize to the displayed size |
Hero loaded with loading="lazy" | LCP equals the image load time, late | Remove lazy loading from the hero |
| Render-blocking CSS or JS | High "resource load delay" | Inline critical CSS, defer the rest |
| Slow server response | TTFB over 800 ms | Caching, CDN, upgrade the plan |
| Web font blocking text | Heading is invisible, then appears | font-display: swap, preload the font |
| Client-side rendered hero | Content appears only after JS runs | Server-render or pre-render the markup |
Fix the Hero Image First
In most audits, the hero image is both the LCP element and the largest byte cost. Compress it, resize it to the largest size it is actually displayed at, and serve a modern format.
<!-- Above the fold: fetch early, never lazy-load -->
<img
src="/assets/hero-1600.webp"
srcset="/assets/hero-800.webp 800w, /assets/hero-1600.webp 1600w"
sizes="(max-width: 800px) 100vw, 1600px"
width="1600" height="900"
alt="Product dashboard on a laptop"
fetchpriority="high"
decoding="async">Three attributes do the heavy lifting. fetchpriority="high" tells the browser this image matters more than the scripts. srcset stops phones from downloading the desktop file. width and height reserve the space so the image cannot shift the layout when it arrives.
Interaction to Next Paint (INP)
INP measures the delay between a user interaction — a tap, click or key press — and the next frame the browser paints in response. It reports the worst interaction of a visit, ignoring outliers beyond a small number per page load.
An interaction has three parts:
| Part | What it covers | How to reduce it |
|---|---|---|
| Input delay | Time before the handler starts | Break up long tasks, yield to the main thread |
| Processing time | Time inside your event handlers | Do less work per handler |
| Presentation delay | Time to paint the next frame | Avoid layout thrashing, batch DOM reads and writes |
Common INP Causes
| Cause | Symptom | Fix |
|---|---|---|
| Long tasks from third-party scripts | Taps feel ignored for a second | Defer or remove tag-manager bloat |
| Heavy hydration | First tap after load is slow | Reduce client-side JavaScript |
| Large DOM | Every update reflows thousands of nodes | Simplify markup, virtualise long lists |
| Synchronous work in handlers | Click triggers a freeze | Move work to a worker or chunk it |
| Layout thrashing | Reading and writing layout in a loop | Batch reads, then writes |
A useful pattern is to yield inside long handlers so the browser can paint between chunks:
// Break a long loop into chunks so the browser can paint between them.
async function processInChunks(items, work) {
for (let i = 0; i < items.length; i++) {
work(items[i]);
if (i % 50 === 0) {
await new Promise((resolve) => setTimeout(resolve, 0));
}
}
}Cumulative Layout Shift (CLS)
CLS quantifies how much visible content moves unexpectedly during load. It is not a speed metric: a page can load slowly and still have a CLS of zero if nothing jumps.
A shift only counts when an existing element changes position without a user action. Content that appears because the visitor scrolled or clicked is excluded, which is why infinite scroll and accordions do not hurt the score.
Common CLS Causes
| Cause | What it looks like | Fix |
|---|---|---|
| Images without dimensions | Text jumps down as images load | Set width and height or aspect-ratio |
| Ads and embeds without reserved space | Content pushes down mid-read | Reserve a fixed-size container |
| Late-loading web fonts | Text reflows when the font swaps | font-display: swap with a matched fallback |
| Banners injected above content | Everything moves at once | Reserve space or overlay instead of insert |
| Dynamic content above the fold | Cookie bars and promos shift the page | Fixed overlay, not document flow |
/* Reserve space for media and embeds so they cannot shift the layout. */
.media-frame {
aspect-ratio: 16 / 9;
width: 100%;
background: #f1f5f9;
}
.ad-slot {
min-height: 280px;
contain: layout;
}Supporting Metrics Worth Tracking
Core Web Vitals are not the whole picture. These supporting metrics explain why a core metric fails.
| Metric | Measures | Good target |
|---|---|---|
| TTFB — Time to First Byte | Server and network latency | 800 ms or less |
| FCP — First Contentful Paint | First text or image painted | 1.8 s or less |
| TBT — Total Blocking Time | Lab proxy for INP | 200 ms or less |
| Speed Index | How quickly content fills the viewport | 3.4 s or less |
| DOM size | Node count in the document | Under 1,500 nodes |
TTFB is the one to watch first. If the server takes 1.5 seconds to respond, no amount of image compression will rescue LCP, because the browser has not received the HTML that references the image.
How to Measure Core Web Vitals
Measure in the same order every time, so comparisons mean something.
- Open Google Search Console and check the Core Web Vitals report for failing URL groups.
- Run the Page Speed Checker on the failing URL to get lab diagnostics.
- Compare field and lab results, and note which phase dominates LCP.
- Fix one cause, then re-measure the same URL with the same tool.
- Re-check field data after 28 days, once the CrUX window has rolled over.
| Tool | Data type | Best for |
|---|---|---|
| Search Console | Field | Finding which URL groups fail |
| PageSpeed Insights | Field and lab | Confirming a cause on one URL |
| Lighthouse in DevTools | Lab | Iterating quickly during a fix |
| Chrome Performance panel | Lab | Finding the exact long task |
| Web Vitals extension | Field (your session) | Spot-checking a page you just changed |
You can also record your own field data from real sessions:
// Log LCP and CLS from real visits (uses the web-vitals library).
import { onLCP, onINP, onCLS } from 'web-vitals';
const send = (metric) => {
navigator.sendBeacon('/analytics/vitals', JSON.stringify({
name: metric.name,
value: metric.value,
id: metric.id,
}));
};
onLCP(send);
onINP(send);
onCLS(send);Fix in the Right Order
Fixing metrics in the wrong order wastes effort, because later fixes get masked by earlier bottlenecks.
| Order | Fix | Metrics improved | Effort |
|---|---|---|---|
| 1 | Server response time and caching | LCP, TTFB, FCP | Medium |
| 2 | Image compression and correct sizing | LCP, CLS, Speed Index | Low |
| 3 | Remove render-blocking CSS and JS | LCP, FCP | Medium |
| 4 | Defer third-party scripts | INP, TBT | Low |
| 5 | Reserve space for media and ads | CLS | Low |
| 6 | Reduce client-side JavaScript | INP, TBT | High |
| 7 | Simplify the DOM | INP, CLS | High |
Work top to bottom. Steps 1 to 5 usually deliver most of the gain, and steps 6 and 7 are the expensive ones that only matter once the cheap wins are in place.
Mobile Testing and Layout
Core Web Vitals are dominated by mobile traffic on most sites, and mobile is where every problem is worst: slower CPUs, higher latency and smaller viewports that trigger different image sizes.
- Test the mobile layout first, not the desktop layout.
- Run the Mobile-Friendly Test Tool on the three key templates.
- Throttle to "Slow 4G" and 4x CPU slowdown in DevTools before trusting a lab score.
- Check that tap targets are at least 48 pixels apart, so taps do not misfire.
- Confirm that no element overflows the viewport, which forces horizontal scroll and extra layout work.
| Template | Test at | Common mobile fault |
|---|---|---|
| Homepage | 360 px wide | Hero image served at desktop size |
| Product or tool page | 360 px wide | Sticky header covering content |
| Blog post | 360 px wide | Wide tables forcing horizontal scroll |
How Core Web Vitals Affect SEO
Core Web Vitals are a tiebreaker, not a trump card. A fast page with thin content will not outrank a slow page that answers the query better. But between two pages of comparable relevance, the one with good vitals has an advantage, and the effect compounds through click-through rate and engagement.
| Signal | Direct ranking effect | Practical impact |
|---|---|---|
| LCP | Small | Slow pages lose visitors before they read |
| INP | Small | Unresponsive pages increase bounces |
| CLS | Small | Mis-taps and frustration reduce return visits |
| Content relevance | Large | The dominant factor |
| Internal linking | Medium | Distributes authority predictably |
The honest framing: fix vitals because they improve conversion and retention, and treat the ranking benefit as a bonus. Sites that chase the score alone usually break something else.
Verify the Improvement
Use the same table before and after a fix round. Field values move slowly, so record lab values immediately and field values after the CrUX window rolls over.
| Check | Before (poor) | After (good) |
|---|---|---|
| LCP (mobile field) | 4.8 s | 2.1 s or less |
| INP (mobile field) | 620 ms | 180 ms or less |
| CLS (mobile field) | 0.31 | 0.05 or less |
| TTFB | 1.4 s | Under 800 ms |
| Hero image weight | 2.1 MB JPEG | 180 KB WebP |
| Third-party scripts on load | 9 | 3, rest deferred |
| Search Console group | "Needs improvement" | "Good" |
Common Mistakes
| Mistake | Why it fails | Better approach |
|---|---|---|
| Optimising only the homepage | Templates fail, not pages | Fix the shared template |
| Chasing a perfect lab score | Lab score is not the ranking input | Target field data at the 75th percentile |
| Lazy-loading the hero | Delays the LCP element | fetchpriority="high" instead |
| Compressing without resizing | Dimensions dominate file size | Resize to displayed size, then compress |
| Removing all third parties | Breaks analytics and business needs | Defer them until after interaction |
| Measuring once | Field data lags and varies | Re-measure over a 28-day window |
Frequently Asked Questions
What are Core Web Vitals in simple terms?
Three measured signals of real user experience: LCP for loading speed, INP for responsiveness and CLS for visual stability. Each is scored good, needs improvement or poor from real Chrome data.
Is FID still a Core Web Vital?
No. First Input Delay was replaced by Interaction to Next Paint in March 2024. INP measures the full interaction latency, while FID only measured input delay.
What is a good LCP score?
2.5 seconds or less at the 75th percentile of real visits. Between 2.5 and 4.0 seconds needs improvement, and anything over 4.0 seconds is poor.
What is a good CLS score?
0.1 or less. Between 0.1 and 0.25 needs improvement, and above 0.25 is poor. Most shifts come from images, ads and fonts without reserved space.
Why does PageSpeed Insights show a good score while Search Console shows failures?
PageSpeed Insights shows a single lab run, while Search Console reports 28 days of field data from real devices. Field data is what counts, and it is usually worse.
Do Core Web Vitals directly affect rankings?
They are a minor ranking signal used as a tiebreaker between pages of similar relevance. Content quality and intent match still dominate.
How long after a fix do scores update?
Lab tools update immediately. Field data in Search Console and CrUX takes up to 28 days to reflect the change, because the reporting window is a rolling 28-day period.
How do I find which element is the LCP element?
In Chrome DevTools, open the Performance panel, record a load, then check the Timings track or the LCP marker in the Experience section. PageSpeed Insights also names the element.
Can a CDN fix poor Core Web Vitals?
It fixes TTFB and helps LCP for geographically distant visitors. It does nothing for oversized images, heavy JavaScript or layout shifts.
Does lazy loading improve Core Web Vitals?
Yes for below-the-fold images, because it saves bandwidth and main-thread work. It hurts LCP when applied to the hero image, which should load eagerly.
What is the fastest single fix for LCP?
Compress and resize the hero image, serve it as WebP and add fetchpriority="high". That combination removes the largest byte cost and starts the fetch earliest.
How many third-party scripts are too many?
There is no fixed limit, but each one adds network and main-thread cost. Audit them quarterly, defer everything non-essential and remove anything nobody reads.
Related Guides and Tools
- Page Speed Checker - measure loading performance and Core Web Vitals for a URL.
- Image Compressor - cut image weight with no visible quality loss.
- Image to WebP Converter - serve modern formats that load faster.
- Image Resizer - resize images to the size they are actually displayed at.
- Image Format Converter - convert between JPEG, PNG, WebP and AVIF.
- Mobile-Friendly Test Tool - check the mobile layout that most visitors see.
- Website SEO Analyzer - a full on-page audit including performance and technical checks.
- How to Optimize Your Website for Better Search Rankings - the nine-step process that uses these metrics.
- 10 Essential Free Online Tools for Business - the wider toolkit for small teams.
- SEO Tools category - browse every SEO tool on the site.
- Image Tools category - browse the image optimization tools.
Conclusion
Core Web Vitals turn "the site feels slow" into three numbers you can measure, compare and fix. LCP tells you how long the main content takes to appear, INP tells you how quickly the page answers a tap, and CLS tells you how much the layout moves while it loads.
Fix them in order: server response first, then images, then render-blocking resources, then third-party scripts, then reserved space for media. Measure with field data to decide whether to act and with lab data to decide what to change, and give every fix 28 days before judging the field result.
Start with the hero image and one third-party script this week. Those two changes alone move LCP and INP on almost every site, and the exported reports give you a baseline to prove it.