In short
- LCP is how long until the biggest thing on the screen appears. INP is how long a tap takes to answer. CLS is how much the page jumps.
- Good is 2.5 seconds, 200 milliseconds and 0.1. Google grades on real visitors at the 75th percentile, so the slow phones count.
- LCP is usually images and the server. INP is usually scripts. CLS is usually images without dimensions and banners injected above content.
- An owner can fix images, remove plugins and cut embeds. Scripts, fonts, caching and templates need a developer.
- Fix in this order: images, scripts, layout. Then test on a phone, and wait a month for Google's data to catch up.
Three questions a customer would ask
A speed test used to give one score, and the industry sold one-score fixes. Then Google replaced it with three measurements, each named with an acronym, and most owners stopped reading at the acronyms.
That is a shame, because the three are the questions a customer would ask in plain words. How long until I can see the thing? Does it answer when I tap it? Did it just jump out from under my thumb? Google calls them Largest Contentful Paint, Interaction to Next Paint and Cumulative Layout Shift, measures them on real visitors, and counts them in ranking. The how fast should a website load guide covers why speed matters and how Google uses it. This one is the repair manual: what each metric means, what breaks it, and what to do, split by whether you need a developer.
One thing before starting. Google grades on the 75th percentile of real visits, so the site has to be good for three visitors out of four, including the ones on old phones with two bars. A site that is fast at your desk can fail all three.
LCP: how long until the biggest thing appears
Largest Contentful Paint is the time from the tap on your link until the largest element in the first screen, usually a hero photo or the headline block, has finished drawing. Good is 2.5 seconds or less. It is the metric most business sites fail, for a short list of reasons.
A big image. The largest element is usually a photo, and the photo is usually too large; a 4-megabyte hero takes seconds on cellular no matter what else is right. A slow server. A second before the first byte is a second added to everything. Render-blocking code. Stylesheets and scripts the browser must download before it draws anything. Lazy-loading the hero. A well-meaning plugin sets every image to load lazily, including the one at the top. Fonts. The headline cannot paint until the custom font arrives.
Fixes for LCP, in order of payoff
- Compress and resize the hero image: under 200 KB, sized to the screen it fills, in a modern format such as WebP or AVIF.
- Make sure the hero is not lazy-loaded and has high fetch priority. A one-line change and a common oversight.
- Add caching and a CDN so the first byte arrives fast. The why is my website slow guide explains a slow first byte.
- Move scripts out of the head or defer them, so the page draws before the plugins run.
- Cut custom fonts to one or two weights, self-host them, and show text in a fallback while they load.
- Replace a full-screen video hero with a still. A video hero rarely reaches a good LCP on cellular.
The largest thing on the screen is the first thing a customer judges. Make it arrive first.
INP: does it answer when tapped
Interaction to Next Paint measures how long the page takes to respond visibly after a tap, click or keystroke. Good is 200 milliseconds or less. It replaced a gentler metric in 2024 and is stricter, because it counts every interaction in the visit, not only the first.
INP is the scripts metric. A page feels dead to the touch when the phone is busy running code: a chat widget starting up, a slider calculating, an analytics tag batching events, a builder's framework wiring up every box. Tap the menu during that and nothing happens for half a second. On a laptop the same code runs in a tenth of the time, which is why owners rarely notice.
The usual causes: too many plugins and scripts, each doing a little work on every tap; heavy embeds such as maps, social feeds and chat tools; menus and forms built with more code than they need; and a builder that renders the page through layers of its own JavaScript.
Fixes for INP
- Remove every plugin, widget and script the site does not need. This is the biggest fix and an owner can do it. Fixing WordPress plugins handles the ones that break things when removed.
- Replace heavy embeds with a still image that loads the real map or video only when tapped.
- Defer scripts not needed for the first screen, so they run after the page is usable.
- Route third-party tags through a tag manager and audit it. Marketing accumulates pixels the way kitchens accumulate mugs.
- Break up long tasks so the browser can answer a tap between chunks. Developer work.
- If the builder itself is the cause, no amount of trimming reaches good. That case is covered at the end.
CLS: does the page jump
Cumulative Layout Shift measures how much visible content moves while the page loads. Good is 0.1 or less. It is the metric behind an experience everyone has had: you go to tap a button, a banner loads above it, the button moves, and you tap an ad instead.
CLS is a discipline metric more than a speed one. It comes from things inserted into the page without space reserved for them: images with no width and height set, so the text jumps down when the photo arrives; banners, cookie notices and announcement bars injected at the top after the content has drawn; custom fonts that reflow every line because they are a different size than the fallback; embeds that start at zero height and expand; content dropped in late by a script above what the visitor is reading.
Fixes for CLS
- Set width and height on every image and video so the browser reserves the space before the file arrives.
- Reserve fixed space for ads, embeds and anything loaded by a script.
- Put banners, notices and announcement bars in the layout from the start, or overlay them so they do not push content.
- Match the fallback font's size to the custom font so the swap does not reflow the page.
- Never insert content above the visitor's current position unless they asked for it.
The whole guide on one card
Print this and hand it to whoever works on the site. If they recognize every row, you are in good hands; if they reach for a plugin, you are not.
| Metric | Good threshold | Most common cause | First fix |
|---|---|---|---|
| LCP (Largest Contentful Paint) | 2.5 seconds or less | Oversized hero image; slow server | Compress and resize the hero; add caching |
| INP (Interaction to Next Paint) | 200 milliseconds or less | Too many scripts and plugins running on the phone | Remove unused plugins; defer the rest |
| CLS (Cumulative Layout Shift) | 0.1 or less | Images without dimensions; banners injected above content | Set image sizes; reserve space for anything injected |
Thresholds are Google's, measured at the 75th percentile of real visits over 28 days. "Needs improvement" runs to 4 seconds, 500 milliseconds and 0.25; past those is "poor."
What you can do versus what needs a developer
Website speed optimization is sold as a mystery so it can be sold as a package. Much of it is not mysterious. Here is the honest split.
What an owner can do this week
- Compress and resize every image over 200 KB, starting with the home page and top service pages. Free tools do this in bulk.
- Delete plugins, widgets and apps the site does not use. Deactivate first, check the site, then delete.
- Remove embeds that do not earn their place: the Instagram feed nobody scrolls, the second map, the chat widget nobody answers.
- Replace a video hero with a photo.
- Turn on the caching your host offers, if it is a checkbox.
- Test on a phone, on cellular, before and after. The load-time guide explains how to test properly.
What needs a developer
- Deferring and splitting scripts without breaking the features they power.
- Self-hosting fonts and matching the fallbacks.
- Fixing the theme or template: render-blocking styles, reserved layout space, image markup with sizes and priorities.
- Configuring a CDN, server caching and image delivery properly.
- Diagnosing INP when the cause is the builder's own framework.
- Anything "optimized" twice already that drifted back. That pattern means the platform, and it is a conversation, not a plugin.
Do the first list before paying for the second. Owners who work through it commonly move LCP out of the red on their own. The how to improve an old website guide puts these steps beside the other repairs an aging site needs. What remains is quoted as a fixed-price speed fix after a free audit says which items apply.
When optimization hits the floor
Every platform has a floor. On a lean coded site it is near zero: the page arrives finished, the phone has little to run, and all three vitals sit in the green by default. On a WordPress site with a page builder the floor is higher, because the builder's framework, the theme's styles and the plugins all run on every visit. Trimming gets a builder site into the green on LCP and CLS with effort. INP often will not move, because the builder is the script.
We see this most on sites optimized more than once. Each pass helps; each update erodes it. At that point there are two honest options: WordPress optimization with ongoing maintenance, which holds a builder site at a respectable score for a monthly fee, or a rebuild on a platform without the floor. The WordPress to Next.js page explains what that involves, and the WordPress versus Next.js guide explains the difference without the sales pitch. Both are legitimate. A third optimization pass sold as if it were the first is not.
Speed pays for what it does downstream: visitors who stay, taps that work, forms that get finished. Once the page is fast on a phone, the mobile design best practices guide covers what to do with it.
Get a number before you compare anyone else.
Tell us what you have and what you want more of. A real person looks before we quote, and the quote is a fixed price you can hold us to.
Want to know what is slowing your site down?
Tell us which of these sounds familiar and we will run the tests, name the causes in order, and tell you which ones you can fix yourself. Free, and the answer is yours to keep.
Which of these sounds like you? (pick any)
Questions people ask
Straight answers
Three measurements Google takes on real visitors: how long until the biggest thing on the screen appears (LCP), how quickly the page answers a tap (INP), and how much the content jumps around while loading (CLS). Good is 2.5 seconds, 200 milliseconds and 0.1. Together they are Google's definition of whether a page feels fast and stable to use.
Run the page through Google's PageSpeed Insights and read the top section, which shows real-visitor data for the last 28 days when the site has enough traffic. Google Search Console has a Core Web Vitals report that lists which pages fail and why. If the site has little traffic there will be no field data, and the lab numbers are the next best guide, read as an optimistic estimate.
INP, on most business sites, because it comes from the total amount of code the phone has to run, and that code is spread across plugins, a theme and third-party tags that each seem to have a reason to exist. LCP is usually one image and one server setting. CLS is usually a missing dimension. INP can mean removing things people are attached to.
Yes. Most WordPress sites can reach the green on LCP and CLS with image work, caching and plugin cleanup. INP is harder on sites built with a page builder, because the builder's own code is the delay. A WordPress site without a builder, on a light theme, with a handful of plugins, can pass all three. One with forty plugins and a builder usually cannot.
Yes, as part of Google's page experience signals. The effect is a tiebreaker between pages with similar content, which matters most in local search, where many pages are similar. Failing them hurts more than passing them helps: getting out of the red matters, and going from good to perfect does not.
The fixes themselves take a few hours to a few days on most sites. Google's field data is measured over a rolling 28-day window, so the reported scores take up to a month to reflect the change. Lab tests show the improvement at once, which is how you confirm the fix worked before the field data catches up.
Where to go from here
