Core Web Vitals in 2026: What They Are and Why They Still Matter

TL;DR: Core Web Vitals are three specific metrics Google uses to measure the real-world experience of loading, interacting with, and visually using your website. They are an official Google ranking factor — part of what Google calls “page experience signals.” In 2026, they remain relevant not just for SEO but as a direct indicator of how likely users are to stay on your site, convert, and return. This guide explains each metric in plain language, how to measure them accurately, what causes poor scores, and the fixes that actually move the needle.

Why Performance Is an SEO Problem, Not Just a UX Problem

There’s a persistent misconception in how local businesses think about website performance. Most owners consider it a design or development concern — something to hand off to a web developer and never think about again. The reality is that website performance is an SEO problem, a conversion problem, and a business problem simultaneously.

Google has used page speed as a ranking signal since 2010 for desktop and since 2018 for mobile. With the rollout of Core Web Vitals as part of the Page Experience update in 2021, performance signals became more specific, more measurable, and more directly tied to real user behaviour rather than synthetic lab scores.

The connection is straightforward: if your website loads slowly, shifts around while people are reading it, or feels unresponsive when they try to interact with it — people leave. Google knows this. And Google uses that knowledge to rank faster, more stable, more responsive websites above slower ones, all else being equal.

For local businesses competing in the same geographic market, Core Web Vitals can be the difference between appearing on page one and page two — particularly in competitive sectors where multiple businesses have comparable backlink profiles and content quality. This connects directly to how Google ranks local businesses using page experience signals alongside relevance and prominence.

What Core Web Vitals Are: The Three Metrics

Google defines Core Web Vitals as a subset of web vitals — specific, quantifiable signals that measure three distinct dimensions of user experience:

1. LCP — Largest Contentful Paint (loading performance)
2. INP — Interaction to Next Paint (responsiveness and interactivity)
3. CLS — Cumulative Layout Shift (visual stability)

Each metric has a defined threshold separating “Good,” “Needs Improvement,” and “Poor” performance. The goal is to pass all three in the “Good” range.

Metric 1: LCP — Largest Contentful Paint

What It Measures

LCP measures how quickly the largest visible element on the page loads and becomes visible to the user. That element is typically a hero image or banner photo, a large block of text above the fold, a video thumbnail, or a background image in a key section.

LCP is essentially answering: “How long does it take before the user can see the main content of this page?”

The Thresholds

Why LCP Matters

A slow LCP means users are staring at a blank or partially loaded screen. Research from Google shows that as page load time increases from 1 second to 3 seconds, the probability of a user bouncing increases by 32%. From 1 to 5 seconds, that probability increases by 90%. For a local business, this directly translates to lost enquiries, lost bookings, and lost revenue — not from ranking drops, but simply from users abandoning the page before it even loads.

What Causes Poor LCP Scores

Slow server response time (TTFB). If your web server takes a long time to respond, everything else is delayed from the start. Server response time over 600ms is a significant LCP problem. Fix: Upgrade to a faster hosting provider. For most small businesses, switching from shared hosting to a VPS or managed WordPress host (e.g., Kinsta, WP Engine, Hetzner) makes an immediate difference.

Unoptimised images. Large images in the wrong format are the single most common cause of poor LCP for small business websites. A 4MB JPEG hero image will kill LCP scores on mobile. Fix: Convert images to WebP or AVIF format. Compress images to under 200KB for standard use. Use responsive images that serve different sizes to different screen sizes. Add the loading="eager" attribute specifically to your LCP image — don’t lazy-load it.

Render-blocking resources. CSS and JavaScript files that load in the <head> block the browser from rendering anything until they’ve fully loaded. Fix: Defer non-critical JavaScript. Inline critical CSS. Remove unused CSS and JS. Use a performance plugin (WP Rocket, Perfmatters) if using WordPress.

No content delivery network (CDN). If your web server is located in Frankfurt and a user in Sarajevo loads your page, every resource must travel that distance. A CDN caches your content at servers closer to users globally. Fix: Enable a CDN. Cloudflare’s free plan works well for most small business websites and immediately improves LCP for geographically distributed visitors.

Metric 2: INP — Interaction to Next Paint

What It Measures

INP (Interaction to Next Paint) replaced First Input Delay (FID) as the interactivity Core Web Vital in March 2024. It measures the delay between a user interacting with a page — clicking a button, tapping a link, submitting a form — and the browser visually responding to that interaction.

FID only measured the delay before the browser began processing the interaction. INP measures the full cycle — from interaction to the browser painting the updated visual response. This makes it a much more comprehensive and user-relevant measure of page responsiveness.

The Thresholds

Why INP Matters

Poor INP means the website feels sluggish and unresponsive. A user taps a navigation button and nothing appears to happen for half a second. They tap it again (thinking the first tap didn’t register) and the action fires twice. This destroys trust and causes immediate abandonment. For local business websites, poor INP typically manifests as contact forms that feel slow to submit, navigation menus that lag on mobile, booking widgets that take noticeable time to respond, and filter functions that feel unresponsive.

What Causes Poor INP Scores

Heavy JavaScript execution. The most common INP killer. When the browser’s main thread is occupied processing JavaScript, it can’t respond to user interactions. Fix: Audit and reduce third-party JavaScript. Every analytics tag, chat widget, social media embed, and ad script that runs on your page adds main-thread processing time. Each individual script may seem minor — in combination they can make INP unacceptably high.

Long tasks on the main thread. JavaScript tasks exceeding 50ms are considered “long tasks.” During a long task, the browser cannot respond to interactions. Fix: For WordPress sites, switching to a lighter theme framework and deactivating unused plugins frequently improves INP significantly.

Inefficient event handling. Poorly written click or form event handlers that do too much synchronous work before returning control to the browser. Fix: Deactivate unused plugins (which often add their own event listeners) and audit your site’s active JavaScript with a developer if INP scores remain poor.

Metric 3: CLS — Cumulative Layout Shift

What It Measures

CLS measures how much the visible page content unexpectedly shifts while loading. It captures the total amount of visual instability experienced by a user — that frustrating phenomenon where you’re about to click a button and it suddenly jumps down the page because an image or ad loaded above it. CLS is measured as a score (not a time), based on how much content moves and how much of the viewport is affected.

The Thresholds

What Causes Poor CLS Scores

Images without width and height attributes. When the browser doesn’t know an image’s dimensions before it loads, it reserves no space for it. When the image loads, everything around it shifts. Fix: Always add explicit width and height attributes to <img> tags. Modern WordPress and major CMSs now do this automatically, but legacy content may still have images without these attributes.

Web fonts causing text reflow. When web fonts take time to load, the browser displays text in a fallback font first. When the web font loads, the text size changes, causing shift. Fix: Use font-display: swap in CSS to maintain layout space for fonts. Preload critical fonts in the <head>. Consider hosting fonts locally rather than loading from Google Fonts — this removes a DNS lookup and external request.

Ads and embeds without reserved space. Ads served by third-party networks often have variable heights. Without reserved space, they push content when they load. Fix: Always define minimum height containers for ad slots. Use min-height CSS on any container whose content loads dynamically.

Cookie consent and notification banners. Popups and consent banners that appear after page load and push content down are a major CLS source. Fix: Design consent banners as overlays (fixed position at bottom or top) rather than elements that push content. Alternatively, reserve space for them in the initial layout.

How to Measure Your Core Web Vitals

Measuring accurately requires understanding the difference between lab data and field data. Lab data is generated by automated tools running controlled tests — consistent and repeatable, useful for debugging, but doesn’t reflect real user conditions. Field data is collected from real users visiting your site — this is what Google uses for ranking.

Primary Measurement Tools

Google Search Console — Core Web Vitals Report. The most important tool. Shows field data from real users of your site, segmented by mobile and desktop, for all URLs with sufficient traffic. Access: Search Console → Experience → Core Web Vitals. Start here.

Google PageSpeed Insights. Provides both lab data (Lighthouse) and field data (Chrome User Experience Report) for any URL. Enter your URL and get an instant score with specific recommendations.

Chrome DevTools Lighthouse. Laboratory test that runs in your browser. Press F12 → Lighthouse → Generate report. Useful for testing local development versions and pages with low traffic. Note: lab scores often differ from field data scores.

Web Vitals Chrome Extension. Displays real-time Core Web Vitals as you browse your own website. Useful for identifying which pages or interactions cause CLS or INP issues.

Core Web Vitals for Local Business Websites: The Specific Risks

Most local business websites share a set of common performance patterns — and common failure points.

The shared hosting problem. Many small local business websites are hosted on cheap shared hosting plans — often the same plan that has been renewed annually for years. Shared hosting means your website shares a server with hundreds or thousands of other websites. When any of them spike in traffic, your server response time degrades. This is the most impactful and most frequently overlooked LCP problem for local business websites.

The builder platform trap. Websites built on page builders (Elementor, Divi, Wix, Squarespace) often generate bloated HTML, load excessive CSS, and execute significant JavaScript. This doesn’t mean these platforms can’t perform — but they require more deliberate optimisation than hand-coded sites.

The plugin accumulation problem. For WordPress sites specifically: every plugin installed adds code that runs on every page load. A contact form plugin, a slider, an SEO plugin, a booking system, a chat widget, a social media feed, an event calendar — individually harmless, collectively devastating to performance.

Mobile-first reality. Google’s Core Web Vitals assessment is weighted toward mobile performance. Most local business web traffic is predominantly mobile. A site that performs well on desktop but poorly on mobile will underperform in rankings.

Core Web Vitals and Local SEO: The Direct Connection

In organic results: Page experience signals (which include Core Web Vitals) are a ranking factor for all pages in organic search. A service page for “dentist Sarajevo” with poor Core Web Vitals competes at a disadvantage against an equivalent page with good scores.

In the Local Pack: Google has indicated that page experience signals influence Local Pack ranking in addition to the primary relevance, distance, and prominence factors. A GBP profile linking to a fast, stable website reinforces positive user experience signals.

In AI search: When AI systems generate recommendations for local businesses, they consider available quality signals — including whether the business’s website provides a good user experience. User experience is increasingly part of the holistic quality assessment AI systems perform.

Your Priority Fix List

Not all fixes are equal in effort or impact. For local businesses, this is the priority order:

High Impact, Low Effort — Do These First

1. Compress and convert images to WebP — do this today
2. Enable Cloudflare (free CDN and caching) — 30 minutes to set up
3. Add width and height to all images — a quick developer task
4. Specify font-display: swap for web fonts — one CSS line

High Impact, Medium Effort

5. Switch to faster hosting — a migration project but transformative for LCP
6. Audit and remove unnecessary plugins (WordPress) — requires testing
7. Configure browser caching and GZIP compression — server or plugin level

High Impact, Higher Effort

8. Audit and reduce third-party JavaScript — requires developer involvement
9. Implement lazy loading for off-screen images — developer task
10. Refactor or replace any long-task JavaScript — developer-level optimisation

Frequently Asked Questions

Core Web Vitals are the technical foundation beneath every other SEO effort. Even the best-optimised Google Business Profile pointing to a slow, unstable website loses conversion at the last step. Pair Core Web Vitals work with schema markup — together they form the complete technical layer of local SEO. This technical foundation also matters for AI SEO — AI systems can only retrieve and cite content they can access and parse quickly. Page speed is also explicitly listed as a technical requirement in our Google AI Overviews ranking playbook. Want to know exactly where your site stands and what to fix first? Get a free technical SEO audit from Viserno →