Short answer: On a typical local business website, LCP is moved by the hero image and how fast the server sends the HTML, INP is moved by third-party scripts (chat, cookie consent, review widgets, tag managers) and heavy page builder JavaScript, and CLS is moved by things that appear after the page starts rendering: cookie banners, announcement bars, web fonts and embeds without reserved space. The targets are LCP of 2.5 seconds or less, INP of 200 ms or less and CLS of 0.1 or less, measured at the 75th percentile of real page loads.
We wrote an earlier post on the fixes that work on cheap shared hosting. This one is about diagnosis: how to tell which part of each metric is slow on a small site, and which fixes are worth your time on WordPress, hosted builders like Wix and Squarespace, and Webflow.
What are the Core Web Vitals thresholds in 2026?
The thresholds haven't changed since INP replaced First Input Delay (FID) as a Core Web Vital on March 12, 2024. Google's PageSpeed Insights documentation uses these values, at the 75th percentile:
| Metric | What it measures | Good | Needs improvement | Poor |
|---|---|---|---|---|
| LCP (Largest Contentful Paint) | When the biggest text block or image in the viewport renders | 2.5 s or less | 2.5 to 4 s | over 4 s |
| INP (Interaction to Next Paint) | How long the page takes to visibly respond to taps, clicks and key presses | 200 ms or less | 200 to 500 ms | over 500 ms |
| CLS (Cumulative Layout Shift) | How much visible content moves unexpectedly | 0.1 or less | 0.1 to 0.25 | over 0.25 |
A page passes when all three are good at the 75th percentile. web.dev recommends looking at mobile and desktop separately, and for a local business, mobile is the one that matters: that's where people look up a phone number in a parking lot.
Do they affect rankings? Google's page experience documentation says "Core Web Vitals are used by our ranking systems", and in the same breath that good scores don't guarantee top rankings and that relevance comes first. Treat them as a user experience problem with some search upside, and don't promise an owner rankings.
Does a small local business site even have field data?
Often no. Field data comes from the Chrome UX Report (CrUX), and a page or origin is only included if it's publicly discoverable and "sufficiently popular". Google doesn't disclose the exact threshold. PageSpeed Insights shows field data over the previous 28 days, falls back to the whole origin if the single page lacks data, and shows nothing if the origin lacks data too.
Wix has its own Site Speed dashboard built from real visitor data, but only for sites with 10 or more sessions in the last seven days.
When there's no field data, you can still collect it yourself. Google's web-vitals library has an attribution build that tells you why a metric is slow, not just the number. Paste this into a test page or the site's footer for a few days and send the results to the console or your analytics:
<script type="module">
import { onLCP, onINP, onCLS } from
'https://unpkg.com/web-vitals@5/dist/web-vitals.attribution.js?module';
onLCP(({ value, attribution: a }) => console.table({
LCP: Math.round(value), element: a.target,
ttfb: Math.round(a.timeToFirstByte),
loadDelay: Math.round(a.resourceLoadDelay),
loadDuration: Math.round(a.resourceLoadDuration),
renderDelay: Math.round(a.elementRenderDelay),
}));
onINP(({ value, attribution: a }) => console.table({
INP: Math.round(value), target: a.interactionTarget,
inputDelay: Math.round(a.inputDelay),
processing: Math.round(a.processingDuration),
presentation: Math.round(a.presentationDelay),
}), { reportAllChanges: true });
onCLS(({ value, attribution: a }) => console.table({
CLS: value.toFixed(3), shifted: a.largestShiftTarget,
}), { reportAllChanges: true });
</script>
Run it on a mid-range Android phone over cellular, not on your laptop. The numbers that come out of a developer machine on office Wi-Fi tell you very little about the owner's customers.
What actually moves LCP on a local business site?
Usually the hero image, and second, an uncached server response. web.dev splits LCP into four subparts and suggests a rough budget for each: time to first byte about 40%, resource load delay under 10%, resource load duration about 40% and element render delay under 10%. The attribution output above gives you all four, so you can see which one is out of budget instead of guessing.
What each one usually means on a small site:
- Time to first byte too high. WordPress building every page on every request on a slow host. A page cache usually fixes this; on hosted builders you can't change it, so move on.
-
Resource load delay too high. The browser found the hero late. Common causes: the hero is a CSS background image set by a page builder, it's injected by a slider script, or it has
loading="lazy"on it. web.dev puts it bluntly: "Never lazy-load your LCP image." - Resource load duration too high. The file is too big. A phone photo uploaded straight from the camera.
- Element render delay too high. The image arrived but wasn't shown yet: render-blocking CSS and fonts, or a hero that stays hidden until a script or entrance animation reveals it.
The most common fix we make is turning a background-image hero into a real image the browser can discover in the HTML:
<!-- Before: hero set as a background in builder CSS, found late -->
<!-- After: a real <img>, discoverable immediately, prioritised -->
<img src="/img/hero-1200.webp"
srcset="/img/hero-800.webp 800w, /img/hero-1200.webp 1200w, /img/hero-1800.webp 1800w"
sizes="100vw" width="1200" height="675"
alt="Technician servicing a furnace in a basement"
fetchpriority="high">
If the theme won't let you change the markup, a <link rel="preload" as="image" fetchpriority="high"> in the head for the background file is the fallback. Use fetchpriority="high" on one image, not five. web.dev notes that setting high priority on more than one or two images makes it unhelpful.
What actually moves INP on a local business site?
Third-party scripts, almost every time. INP has three phases: input delay (the main thread is busy when the user taps), processing duration (your event handlers run) and presentation delay (the browser renders the next frame). On small sites the input delay is usually the long one, because a chat widget, a consent manager, a reviews carousel and a tag manager full of old pixels are all running JavaScript while someone taps "Call now".
Look at interactionTarget in the attribution data. If the slow interactions are on the menu button or the cookie banner itself, the problem is that component. If they're spread across the page, it's background script work.
Fixes, in the order we try them:
- Delete what nobody uses. Ask the owner about every third-party tag. Ad pixels from finished campaigns are common.
- Load chat and review widgets on interaction or after the page settles, not on page load.
- Replace page builder mega menus with a plain HTML menu and a few lines of CSS. A local business with six services doesn't need a JavaScript menu.
- Yield in your own handlers. If your code does real work on click, show the visual response first and do the rest after the browser has painted. web.dev's advice is to "yield to the main thread often":
const yieldToMain = () => new Promise((r) => setTimeout(r, 0));
quoteForm.addEventListener('submit', async (e) => {
e.preventDefault();
submitButton.disabled = true;
submitButton.textContent = 'Sending...'; // user sees this right away
await yieldToMain(); // let the browser paint
await sendQuoteRequest(new FormData(quoteForm));
trackConversion(); // non-urgent work last
});
What actually moves CLS on a local business site?
Things that appear late and push content down. The usual list on small sites:
-
Cookie banners and announcement bars inserted at the top of the page after load. Make them overlay the content (
position: fixed) instead of pushing it. -
Images and embeds without reserved space. Maps, booking widgets and video iframes. Give them
widthandheightor anaspect-ratio. -
Web fonts swapping in with different metrics from the fallback. web.dev recommends adjusting the fallback with
size-adjustand related descriptors so the swap barely moves anything. -
Animations of
top,leftorheight. Animatetransforminstead; transforms don't cause layout shifts.
/* Reserve space for the booking widget before its script loads */
.booking-embed { aspect-ratio: 4 / 5; width: 100%; max-width: 480px; }
@media (min-width: 768px) { .booking-embed { aspect-ratio: 16 / 10; max-width: none; } }
/* Make the fallback font take up roughly the same space as the web font */
@font-face {
font-family: "Brand Fallback";
src: local("Arial");
size-adjust: 104%; /* tune by comparing the two fonts on screen */
}
h1, h2 { font-family: "Brand", "Brand Fallback", sans-serif; }
One detail that saves time: layout shifts within 500 ms of a tap or keypress are excluded from CLS, because the user expected something to change. An accordion that opens on tap isn't your problem. A review widget that loads three seconds later and shoves the contact form down is.
What can you actually change on WordPress, Wix, Squarespace and Webflow?
Less than you'd like on hosted builders, nearly everything on WordPress and hand-coded sites. That should decide where you spend your hour.
WordPress deserves a special note. W3Techs reports that Elementor is used on 31.5% of WordPress sites as of November 2026, so a lot of the local business sites you'll audit are WordPress plus a page builder. Check the builder's own performance options first, then remove sections and widgets that load scripts, before reaching for another optimization plugin.
On Wix and Squarespace you can't touch the server or the platform's own scripts. What you control is what the owner added: image sizes, installed apps, fonts, embeds, and how much is crammed into the first screen.
In what order should you fix things?
Fix whichever metric is failing in field data first, and within it, the subpart that's furthest over budget.
Then tell the owner what changed in their terms, without promising rankings. A fictional example:
Your homepage photo was being loaded last, after the chat widget and two old ad tags. I made the photo load first and removed the tags you said you don't use. On my test phone the page now shows the photo and your phone number noticeably sooner. Google's public data updates over 28 days, so we'll check the report again next month.
Finding sites that fail Core Web Vitals
The manual way: search a trade and a town, run the top results through PageSpeed Insights, and note which ones fail on mobile. It takes about a minute per site.
If you'd rather start with a list, LeadReef finds local businesses whose websites are outdated, broken on mobile or missing, shows what's wrong with each one, and helps with a first mockup and outreach message. You decide who to contact and send it yourself. The first 10 leads are free. Full disclosure: we build LeadReef. Everything above works without it.
Frequently asked questions
What is a good LCP for a small business website?
2.5 seconds or less at the 75th percentile of page loads, on mobile. Between 2.5 and 4 seconds needs improvement, and over 4 seconds is poor.
Why does PageSpeed Insights show no field data for my client's site?
The site doesn't have enough Chrome traffic to be included in the Chrome UX Report. Google doesn't publish the threshold. Use the lab results and collect your own data with the web-vitals library.
Is FID still a Core Web Vital?
No. INP replaced FID on March 12, 2024. If a report or plugin still shows FID as a Core Web Vital, it's out of date.
How long until fixes show up in PageSpeed Insights?
Lab results change right away. Field data covers the previous 28 days, so it improves gradually over about four weeks after the fix goes live.
Will passing Core Web Vitals improve my client's Google rankings?
It might help a little, but don't promise it. Google says Core Web Vitals are used by its ranking systems, and also that good scores don't guarantee top rankings and that relevance comes first.
Sources (checked November 2026): web.dev, Web Vitals; web.dev, Interaction to Next Paint becomes a Core Web Vital on March 12; web.dev, Optimize Largest Contentful Paint; web.dev, Optimize Interaction to Next Paint; web.dev, Optimize Cumulative Layout Shift; Google, About PageSpeed Insights; Chrome for Developers, CrUX methodology; Google Search Central, Understanding page experience; GoogleChrome, web-vitals library; Wix Help Center, Understanding your Site Speed dashboard; W3Techs, Usage statistics of WordPress.



Top comments (0)