Core Web Vitals — How Site Speed Affects Google Rankings
Core Web Vitals is a set of three Google metrics (LCP, INP, CLS) measuring loading speed, interactivity, and visual stability of a page. In our audits, this is one of the few areas of SEO where the numbers are unambiguous — a page either falls within the threshold or it doesn't, with no room for interpretation.
What Google Says About Core Web Vitals and Rankings
Google states plainly that Core Web Vitals are used by its ranking systems and highly recommends that site owners achieve good scores (Google's documentation on Core Web Vitals). The same documentation notes that there is no single page experience signal, and that Search always seeks to show the most relevant content, even if the page experience is sub-par (Google's documentation on page experience).
What does this mean in practice? Here is how we read it: CWV doesn't decide anything on its own and won't replace content that matches the query, but between similarly relevant pages it can tip the balance — and there are more such cases in search results than most companies assume.
The Three Core Web Vitals Metrics
1. LCP — Largest Contentful Paint
What it measures: The time from page entry to rendering the largest visible element on screen (hero image, headline, video).
Thresholds:
- 🟢 Good: <2.5 seconds
- 🟡 Needs improvement: 2.5-4 seconds
- 🔴 Poor: >4 seconds
Why it matters: LCP is the moment when the user sees the "real" page. Before LCP, they see a blank page or fragments.
Common problems:
- Large hero images without optimization (5 MB PNG instead of 100 KB WebP)
- Slow server (long TTFB; web.dev gives 0.8 seconds as a rough threshold to aim for)
- Render-blocking CSS/JS — the browser can't display the page because it's loading scripts
- Third-party scripts (chat, analytics, ads) blocking rendering
- No CDN — server in the US, user in Europe
In our experience, that first item accounts for most of the audits where LCP comes back red — an unoptimized hero image that nobody ever bothered to compress.
How to fix:
- Images: WebP/AVIF, lazy loading (outside first viewport), preload hero image, srcset with responsive sizes
- Server: TTFB of about 0.8 s or less — consider CDN, edge rendering, SSG (Next.js generates static files)
- CSS: Inline critical CSS, async load the rest
- JS: Defer/async, code splitting, remove unused libraries
- Fonts:
font-display: swap, preload for critical fonts
2. INP — Interaction to Next Paint
What it measures: The time from a user interaction (click, tap, key press) to a visible page reaction. Replaced FID (First Input Delay) in March 2024.
Thresholds:
- 🟢 Good: <200 milliseconds
- 🟡 Needs improvement: 200-500 milliseconds
- 🔴 Poor: >500 milliseconds
Why it matters: INP measures responsiveness. You click a button — how long until something changes on screen? 200ms is the upper limit of a good score according to Google. Above that, users start to feel the delay. In our view, this is the most underrated of the three metrics — LCP and CLS are visible at a glance on a screen recording, INP has to be measured, so it's easy to forget about until users start complaining that the site "feels stuck."
Common problems:
- Heavy JavaScript blocking the main thread
- Event handlers with heavy computations
- Too many re-renders (React without memoization)
- Third-party scripts (chat widgets, analytics)
- An overly large DOM tree
How to fix:
- Less JS: Code splitting, tree shaking, remove unused libraries
- Web Workers: Move heavy computations off the main thread
- React: useMemo, useCallback, React.memo, lazy loading components
- Debounce/throttle: event handlers, scroll listeners
- Third-party audit: Measure the impact of each external script
3. CLS — Cumulative Layout Shift
What it measures: The visual instability of a page. How many elements "jump" during loading.
Thresholds:
- 🟢 Good: <0.1
- 🟡 Needs improvement: 0.1-0.25
- 🔴 Poor: >0.25
Why it matters: The worst UX is trying to click a button that suddenly shifts 200px down because an ad banner loaded. CLS measures exactly this problem. It's also the cheapest of the three metrics to fix — in our audits, adding width/height to images is usually enough to flip the score from red to green without touching the site's architecture.
Common problems:
- Images and video without defined dimensions (width/height)
- Dynamically loaded ads and embeds
- Web fonts causing FOUT/FOIT (flash of unstyled/invisible text)
- Dynamically injected content (banners, cookie consent)
- CSS animations changing element dimensions
How to fix:
- Always define dimensions:
<img width="800" height="600">or aspect-ratio in CSS - Reserve space: Placeholder for dynamic content (ads, embeds)
- Font-display: optional or swap with a good fallback font
- Avoid insertBefore: Don't inject elements above existing content
- Transform animations: Use
transforminstead oftop/left/width/height
How to Measure Core Web Vitals
Tools with Real Data (Field Data)
Real User Monitoring — data from real users.
| Tool | Cost | What It Provides |
|---|---|---|
| Google Search Console | Free | CWV report, problematic URLs |
| PageSpeed Insights | Free | CrUX data + Lighthouse lab data |
| CrUX Dashboard | Free | Historical 28-day data |
| Chrome UX Report | Free | BigQuery, raw data |
Lab Tools (Lab Data)
Simulated tests — repeatable, controlled conditions.
| Tool | Cost | What It Provides |
|---|---|---|
| Lighthouse (Chrome DevTools) | Free | Full performance report |
| WebPageTest | Free | Waterfall, filmstrip, multi-location |
| Chrome DevTools Performance | Free | Flame chart, main thread analysis |
Continuous Monitoring
| Tool | Cost | What It Provides |
|---|---|---|
| Sentry Performance | Free/Pro | Error tracking + performance |
| SpeedCurve | Paid | Continuous monitoring, alerts |
Pro tip: field data matters more than lab data. Lighthouse in DevTools gives quick answers, but the Core Web Vitals report in Search Console shows field data from CrUX. We see this confusion regularly: a client shows us a green Lighthouse score and asks why Google Search Console is still reporting poor CWV — Lighthouse measures one simulated page load, CrUX collects data from real users on real devices, and that data describes the experience Google assesses.
CWV Impact on Rankings — What We Know
Google doesn't publish how many positions an improvement in Core Web Vitals moves a page, and there's no reason to trust numbers that promise it. What we know is what the documentation says: CWV are used by the ranking systems, other aspects of page experience don't directly help a page rank higher, and relevance comes first (Google's documentation on page experience).
Note: CWV isn't a ranking switch. Content that clearly answers the query better can win despite a slower site; between similarly relevant pages, speed can tip the balance. This distinction gets lost in client conversations more often than it should: some treat CWV as a magic ranking switch, others wave it off as a "technical detail." The truth sits in between — and the effect of an improvement is something you check in your own Search Console data, not in someone else's promises.
How to Quickly Improve CWV (Quick Wins)
5 minutes — immediate results:
- Add
widthandheightto all<img>(CLS) - Add
loading="lazy"to images outside the first viewport (LCP) - Add
font-display: swapin CSS (CLS)
30 minutes — significant improvement:
- Convert images to WebP (LCP — according to Google's WebP documentation, lossy WebP is 25–34% smaller than a comparable JPEG)
- Move third-party scripts to
deferorasync(INP) - Inline critical CSS (LCP)
- Preload hero image and critical fonts (LCP)
A few hours — foundation:
- Implement a CDN (LCP — TTFB)
- Enable HTTP/2 or HTTP/3 (LCP)
- Audit and remove unused JS libraries (INP)
Major change — architectural:
- Migrate to SSG/SSR (e.g. Next.js) — ready-made HTML without waiting for the server
- Image optimization pipeline (responsive images, AVIF)
- Edge rendering, close to the user
CWV and Next.js
What in Next.js helps with Core Web Vitals?
| Mechanism | CWV Effect |
|---|---|
| Static Site Generation (SSG) | LCP: HTML ready, zero server-side rendering |
| Automatic code splitting | INP: Only load JS needed for the current page |
| Next/Image | LCP + CLS: Automatic optimization, WebP, lazy loading, dimensions |
| Next/Font | CLS: Zero layout shift with fonts |
| Edge Runtime | LCP: Rendering close to user, shorter TTFB |
| Streaming SSR | LCP: Progressive rendering — user sees content sooner |
We build a typical Next.js site with our optimizations for Core Web Vitals judged on real-user data (CrUX), not for a lab score. No tricks, no cache, no premium CDN. We're not writing this as a technology ad — the site you're reading this on runs the same stack.
CWV Checklist
LCP (<2.5s)
- Hero image in WebP/AVIF, <200 KB
- Preload hero image
- TTFB of about 0.8 s or less
- Critical CSS inline
- No render-blocking JS
INP (<200ms)
- Main thread not blocked >200ms
- Third-party scripts defer/async
- Event handlers optimized
- Code splitting active
CLS (<0.1)
- All images have width/height
- Fonts with font-display: swap/optional
- No dynamically injected content above the fold
- Ads/embeds with reserved space
Summary
Core Web Vitals is not a buzzword — it's a set of measurable metrics with concrete thresholds that, according to Google, are used by its ranking systems. They won't replace relevant content, but a slow site loses users before they get a chance to judge it.
The fastest path to green CWV? Modern technology (Next.js), optimized images, minimal JavaScript, and a CDN. If there's one thing worth taking away from this guide, make it this: CWV isn't a quarterly project — it's a state you either maintain or lose with every subsequent change to the site.
Want to check your site's CWV? Request a free performance audit — we'll measure and show you what to improve.
Want similar results? Get a free quote.