Understanding Core Web Vitals: A Complete Guide

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.

MetricMeasuresGoodNeeds improvementPoor
LCP — Largest Contentful PaintLoading speed of the main content2.5 s or less2.5 s to 4.0 sOver 4.0 s
INP — Interaction to Next PaintResponsiveness to taps and clicks200 ms or less200 ms to 500 msOver 500 ms
CLS — Cumulative Layout ShiftVisual stability during load0.1 or less0.1 to 0.25Over 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.

SourceWhat it measuresStrengthWeakness
Field data (CrUX, Search Console)Real visitors on real devicesReflects what users experienceLags by up to 28 days
Lab data (Lighthouse, PageSpeed Insights)A simulated run on a fixed profileReproducible, gives specific fixesCannot 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.

PhaseWhat happensTypical fix
Time to first byteServer respondsCaching, faster hosting, CDN
Resource load delayBrowser waits before fetching the heroPreload the image, remove render-blocking CSS
Resource load timeThe hero downloadsCompress, resize, serve WebP or AVIF
Element render delayBrowser paints after downloadRemove blocking scripts, defer fonts

Common LCP Causes

CauseHow to recognise itFix
Oversized hero imageA 2 MB JPEG above the foldCompress and resize to the displayed size
Hero loaded with loading="lazy"LCP equals the image load time, lateRemove lazy loading from the hero
Render-blocking CSS or JSHigh "resource load delay"Inline critical CSS, defer the rest
Slow server responseTTFB over 800 msCaching, CDN, upgrade the plan
Web font blocking textHeading is invisible, then appearsfont-display: swap, preload the font
Client-side rendered heroContent appears only after JS runsServer-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.

HTML
<!-- 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:

PartWhat it coversHow to reduce it
Input delayTime before the handler startsBreak up long tasks, yield to the main thread
Processing timeTime inside your event handlersDo less work per handler
Presentation delayTime to paint the next frameAvoid layout thrashing, batch DOM reads and writes

Common INP Causes

CauseSymptomFix
Long tasks from third-party scriptsTaps feel ignored for a secondDefer or remove tag-manager bloat
Heavy hydrationFirst tap after load is slowReduce client-side JavaScript
Large DOMEvery update reflows thousands of nodesSimplify markup, virtualise long lists
Synchronous work in handlersClick triggers a freezeMove work to a worker or chunk it
Layout thrashingReading and writing layout in a loopBatch reads, then writes

A useful pattern is to yield inside long handlers so the browser can paint between chunks:

JavaScript
// 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

CauseWhat it looks likeFix
Images without dimensionsText jumps down as images loadSet width and height or aspect-ratio
Ads and embeds without reserved spaceContent pushes down mid-readReserve a fixed-size container
Late-loading web fontsText reflows when the font swapsfont-display: swap with a matched fallback
Banners injected above contentEverything moves at onceReserve space or overlay instead of insert
Dynamic content above the foldCookie bars and promos shift the pageFixed overlay, not document flow
CSS
/* 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.

MetricMeasuresGood target
TTFB — Time to First ByteServer and network latency800 ms or less
FCP — First Contentful PaintFirst text or image painted1.8 s or less
TBT — Total Blocking TimeLab proxy for INP200 ms or less
Speed IndexHow quickly content fills the viewport3.4 s or less
DOM sizeNode count in the documentUnder 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.

  1. Open Google Search Console and check the Core Web Vitals report for failing URL groups.
  2. Run the Page Speed Checker on the failing URL to get lab diagnostics.
  3. Compare field and lab results, and note which phase dominates LCP.
  4. Fix one cause, then re-measure the same URL with the same tool.
  5. Re-check field data after 28 days, once the CrUX window has rolled over.
ToolData typeBest for
Search ConsoleFieldFinding which URL groups fail
PageSpeed InsightsField and labConfirming a cause on one URL
Lighthouse in DevToolsLabIterating quickly during a fix
Chrome Performance panelLabFinding the exact long task
Web Vitals extensionField (your session)Spot-checking a page you just changed

You can also record your own field data from real sessions:

JavaScript
// 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.

OrderFixMetrics improvedEffort
1Server response time and cachingLCP, TTFB, FCPMedium
2Image compression and correct sizingLCP, CLS, Speed IndexLow
3Remove render-blocking CSS and JSLCP, FCPMedium
4Defer third-party scriptsINP, TBTLow
5Reserve space for media and adsCLSLow
6Reduce client-side JavaScriptINP, TBTHigh
7Simplify the DOMINP, CLSHigh

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.

  1. Test the mobile layout first, not the desktop layout.
  2. Run the Mobile-Friendly Test Tool on the three key templates.
  3. Throttle to "Slow 4G" and 4x CPU slowdown in DevTools before trusting a lab score.
  4. Check that tap targets are at least 48 pixels apart, so taps do not misfire.
  5. Confirm that no element overflows the viewport, which forces horizontal scroll and extra layout work.
TemplateTest atCommon mobile fault
Homepage360 px wideHero image served at desktop size
Product or tool page360 px wideSticky header covering content
Blog post360 px wideWide 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.

SignalDirect ranking effectPractical impact
LCPSmallSlow pages lose visitors before they read
INPSmallUnresponsive pages increase bounces
CLSSmallMis-taps and frustration reduce return visits
Content relevanceLargeThe dominant factor
Internal linkingMediumDistributes 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.

CheckBefore (poor)After (good)
LCP (mobile field)4.8 s2.1 s or less
INP (mobile field)620 ms180 ms or less
CLS (mobile field)0.310.05 or less
TTFB1.4 sUnder 800 ms
Hero image weight2.1 MB JPEG180 KB WebP
Third-party scripts on load93, rest deferred
Search Console group"Needs improvement""Good"

Common Mistakes

MistakeWhy it failsBetter approach
Optimising only the homepageTemplates fail, not pagesFix the shared template
Chasing a perfect lab scoreLab score is not the ranking inputTarget field data at the 75th percentile
Lazy-loading the heroDelays the LCP elementfetchpriority="high" instead
Compressing without resizingDimensions dominate file sizeResize to displayed size, then compress
Removing all third partiesBreaks analytics and business needsDefer them until after interaction
Measuring onceField data lags and variesRe-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.

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.

We Value Your Privacy

We use cookies to improve your browsing experience, analyze traffic, and display relevant advertisements.