Core Web Vitals Guide: LCP, INP, and CLS Explained
Complete guide to Core Web Vitals for SEO. Learn what LCP, INP, and CLS measure, how to test them, and how to improve your scores for better rankings.
Core Web Vitals are Google’s specific metrics for measuring user experience. Since becoming ranking factors, they’ve transformed how we think about page performance. This guide explains what each metric measures and how to optimize for them.
What Are Core Web Vitals?
Core Web Vitals (CWV) are three specific metrics that measure loading performance, interactivity, and visual stability:
- LCP (Largest Contentful Paint) - Loading
- INP (Interaction to Next Paint) - Interactivity
- CLS (Cumulative Layout Shift) - Visual stability
These metrics became part of Google’s page experience signals in 2021 and continue to influence rankings.
LCP: Largest Contentful Paint
What LCP Measures
LCP measures how quickly the main content of a page loads. Specifically, it marks when the largest image or text block is visible in the viewport.
Common LCP elements:
- Hero images
- Header images
- Large text blocks
- Video poster images
LCP Thresholds
| Score | Rating |
|---|---|
| ≤2.5s | Good |
| 2.5-4s | Needs Improvement |
| >4s | Poor |
What Causes Poor LCP
1. Slow server response time
- TTFB (Time to First Byte) delays everything else
- Database queries, server processing, network latency
2. Render-blocking resources
- CSS that must be downloaded before rendering
- Synchronous JavaScript in the head
3. Slow resource load times
- Large, unoptimized images
- Uncompressed files
- No CDN usage
4. Client-side rendering
- JavaScript must execute before content appears
- Framework hydration delays
How to Improve LCP
Optimize your server:
- Use a CDN
- Implement server-side caching
- Upgrade hosting if needed
- Target TTFB under 200ms
Optimize the LCP element:
- Preload the LCP image:
<link rel="preload" as="image" href="hero.webp"> - Use modern formats (WebP, AVIF)
- Serve appropriately sized images
- Inline critical CSS
Reduce blocking time:
- Defer non-critical JavaScript
- Remove unused CSS/JS
- Use
asyncordeferon scripts
INP: Interaction to Next Paint
What INP Measures
INP (Interaction to Next Paint) replaced FID in March 2024. It measures responsiveness by tracking the latency of all user interactions throughout the page lifecycle.
Interactions INP measures:
- Clicks
- Taps
- Key presses
INP reports the worst interaction latency, ignoring outliers.
INP Thresholds
| Score | Rating |
|---|---|
| ≤200ms | Good |
| 200-500ms | Needs Improvement |
| >500ms | Poor |
What Causes Poor INP
1. Long JavaScript tasks
- Tasks over 50ms block the main thread
- User can’t interact while tasks run
2. Large JavaScript bundles
- More code = more execution time
- Framework overhead
3. Poor event handler performance
- Slow handlers delay response
- Complex operations on interaction
4. Too many DOM elements
- Large DOM trees are slow to update
- More elements = more work
How to Improve INP
Break up long tasks:
// Instead of one long task
function processAll(items) {
items.forEach(item => processItem(item)); // May block for 200ms+
}
// Break into smaller chunks
function processInChunks(items) {
const chunk = items.splice(0, 10);
chunk.forEach(item => processItem(item));
if (items.length > 0) {
requestIdleCallback(() => processInChunks(items));
}
}
Reduce JavaScript:
- Remove unused code
- Split code into smaller bundles
- Load features on demand
- Use lighter alternatives to heavy libraries
Optimize event handlers:
- Debounce scroll/resize handlers
- Use passive event listeners
- Move heavy computation to web workers
Reduce DOM size:
- Target under 1,500 elements
- Virtualize long lists
- Remove hidden elements instead of hiding with CSS
CLS: Cumulative Layout Shift
What CLS Measures
CLS measures visual stability by tracking unexpected layout shifts during the page’s lifecycle. A layout shift occurs when a visible element changes its position from one rendered frame to the next.
What counts as a shift:
- Elements moving after initial render
- Images loading without dimensions
- Ads/embeds inserting content
- Fonts swapping and causing reflow
What doesn’t count:
- Shifts caused by user interaction (within 500ms)
- Smooth animations using
transform
CLS Thresholds
| Score | Rating |
|---|---|
| ≤0.1 | Good |
| 0.1-0.25 | Needs Improvement |
| >0.25 | Poor |
What Causes Poor CLS
1. Images without dimensions
- Browser can’t reserve space
- Content jumps when image loads
2. Ads, embeds, and iframes
- Dynamic content injection
- Unknown sizes until loaded
3. Dynamic content insertion
- JavaScript adding content above existing content
- Toast notifications pushing content
4. Web fonts causing FOIT/FOUT
- Flash of Invisible/Unstyled Text
- Text reflows when font loads
How to Improve CLS
Always include dimensions:
<!-- Bad - no dimensions -->
<img src="photo.jpg" alt="Photo">
<!-- Good - explicit dimensions -->
<img src="photo.jpg" alt="Photo" width="800" height="600">
<!-- Also good - CSS aspect ratio -->
<img src="photo.jpg" alt="Photo" style="aspect-ratio: 4/3; width: 100%;">
Reserve space for dynamic content:
<!-- Reserve space for ad -->
<div style="min-height: 250px;">
<!-- Ad will load here -->
</div>
Optimize font loading:
/* Preload your font */
<link rel="preload" href="font.woff2" as="font" crossorigin>
/* Use font-display: swap or optional */
@font-face {
font-family: 'Custom Font';
font-display: swap;
src: url('font.woff2') format('woff2');
}
Never insert content above existing content:
// Bad - inserts above visible content
container.prepend(newElement);
// Better - insert below fold or at bottom
container.append(newElement);
// Or animate smoothly
newElement.style.opacity = 0;
container.append(newElement);
// Fade in
Measuring Core Web Vitals
Lab Testing (Synthetic)
PageSpeed Insights:
- Provides both lab and field data
- Lighthouse scores and metrics
- Specific recommendations
Chrome DevTools:
- Performance panel for detailed analysis
- Lighthouse audit tab
- Web Vitals extension for live monitoring
WebPageTest:
- Test from multiple locations
- Film strip and waterfall views
- Compare before/after changes
Field Data (Real Users)
Chrome User Experience Report (CrUX):
- Real user data from Chrome
- Powers Search Console and PageSpeed Insights
- 28-day rolling average
Google Search Console:
- Core Web Vitals report
- Groups URLs by status
- Shows trends over time
If that report tells you your Core Web Vitals assessment failed, that verdict is based on field data for the whole URL group, not the single page you happened to test — which is why a page can pass Lighthouse and still fail. To check your own pages against both, run the Core Web Vitals checker.
Real User Monitoring (RUM):
- Web Vitals JavaScript library
- Custom analytics integration
- Detailed debugging data
Lab vs Field Differences
Lab and field data often differ because:
- User devices vary: Your test machine is fast; user devices vary
- Network conditions vary: Lab uses consistent connection; real varies
- User behavior varies: Lab tests cold loads; users may have cache
- Geographic variation: Lab tests one location; users are global
Focus on field data for actual ranking impact — see field data vs lab data for how to reconcile the two when they disagree.
Core Web Vitals and SEO
Impact on Rankings
Core Web Vitals are a ranking factor, but context matters:
- They’re a tiebreaker: Content relevance matters more
- They affect Page Experience: Part of broader page experience signals
- Mobile vs Desktop: Scored separately
- Threshold-based: Good vs needs-improvement vs poor
When CWV Matters Most
- Competitive SERPs: When content quality is equal
- Mobile searches: Mobile CWV often harder to pass
- User experience industries: Travel, e-commerce, news
When CWV Matters Less
- Unique content: Great content can rank despite poor CWV
- Low competition: Less need for tiebreakers
- Informational queries: Where content depth matters more
Core Web Vitals Checklist
LCP Optimization
- TTFB under 200ms
- LCP image preloaded
- Images use modern formats (WebP/AVIF)
- No render-blocking resources
- CDN implemented
- Server-side caching active
INP Optimization
- No JavaScript tasks over 50ms
- Unused JavaScript removed
- Event handlers optimized
- DOM size under 1,500 elements
- Code splitting implemented
CLS Optimization
- All images have dimensions
- Ads/embeds have reserved space
- Fonts use font-display: swap
- No above-the-fold content injection
- Animations use transform/opacity
Monitoring
- Field data tracked (Search Console)
- RUM implemented for detailed data
- Alerts set for regressions
- Regular performance audits
Related Resources:
Tags:
Share this article:
Ready to improve your SEO?
Get a free SEO audit and see exactly what needs fixing on your site
Start Free Audit