Core Web Vitals explained
Core Web Vitals are three measures of how a page feels to use: how fast the main content loads (LCP), how quickly it reacts (INP) and how stable it is (CLS). A page is “good” when LCP is 2.5 seconds or less, INP is 200 milliseconds or less and CLS is 0.1 or less, measured at the 75th percentile of visits.
The three measures
“75th percentile” means that at least three out of four visits must meet the threshold. One fast test on your own phone is not enough.
| Measure | What it shows | Good | Needs work |
|---|---|---|---|
| LCP (Largest Contentful Paint) | How long the biggest visible item, often a hero image or heading, takes to appear | 2.5 s or less | Over 4 s is poor |
| INP (Interaction to Next Paint) | How quickly the page responds when someone taps, clicks or types | 200 ms or less | Over 500 ms is poor |
| CLS (Cumulative Layout Shift) | How much the layout jumps around while loading | 0.1 or less | Over 0.25 is poor |
Why they matter
Fast, steady pages are nicer for visitors, and visitors who are not frustrated are more likely to read, call or buy. Google also uses page experience signals in search. Content quality still matters most, so do not expect speed alone to lift a weak page.
How to measure
Field data (real visits) is what counts. Lab data is useful to debug, but it is a single test on one device.
- PageSpeed Insights. Enter a page address. If enough real visits exist, you see field data from real users. You also see lab data from a test.
- Search Console. The Core Web Vitals report groups your pages and shows which need work.
- Browser developer tools. Lighthouse and the performance panel help you find the cause on a single page.
How to fix a slow LCP
- Compress images and serve them at the size they are shown. Use modern formats such as WebP. Our image compressor can help.
- Do not lazy-load the main image at the top of the page.
- Reduce server response time with caching or a closer host.
- Remove render-blocking scripts and styles, or load them later.
- Keep fonts light, or use system fonts.
How to fix a poor INP
- Ship less JavaScript, and remove scripts you do not use.
- Break long tasks into smaller ones so the page can react between them.
- Delay chat widgets, trackers and tag managers until after the page is usable.
- Keep click handlers simple.
How to fix CLS
- Always set width and height on images and video.
- Reserve space for ads, banners and embeds before they load.
- Do not insert content above what the visitor is already reading.
- Load fonts in a way that does not make text jump.
What ads do to your scores
Ads bring scripts, images and late-loading boxes. They often hurt LCP, INP and CLS. If you show ads, give every slot a fixed height, load the scripts late and test the page with ads switched on.
A simple order of work
- Check your key pages in PageSpeed Insights.
- Fix the biggest images first.
- Reserve space for anything that loads late.
- Remove scripts you do not need.
- Re-test after a few weeks, because field data updates slowly.
How to read a PageSpeed Insights report
PageSpeed Insights shows two kinds of results. The top part, “Discover what your real users are experiencing”, uses field data from real visits, but only when your page has enough of them. New sites often show “No data” here. The “Diagnose performance issues” part is a lab test of one visit on a simulated device. It gives a score from 0 to 100: 90 to 100 is good, 50 to 89 needs improvement and below 50 is poor.
Look at the Mobile and Desktop tabs separately. Mobile is tested on a slower simulated phone and network, so its score is usually lower. In the lab test, look at these numbers first:
- First Contentful Paint (FCP): when anything first appears.
- Largest Contentful Paint (LCP): when the main content appears.
- Total Blocking Time (TBT): how long scripts freeze the page. A lab test cannot measure INP directly, and TBT is a related lab measure.
- Cumulative Layout Shift (CLS): how much the page jumps.
What the common messages usually mean
| Message | What it usually means | Typical fix |
|---|---|---|
| Render-blocking requests | Style or script files must load before the page can be shown | Inline small CSS, and defer scripts |
| Reduce unused JavaScript | Scripts load code that the page does not use, often from third-party tags | Remove tags you do not need, or load them after the first touch |
| Use efficient cache lifetimes | Files could be kept by the browser for longer | Set long cache times on files that carry a version number |
| Properly size images | Images are bigger than the space they fill | Resize and compress them |
| Avoid long main-thread tasks | One script blocks the page for more than 50 milliseconds | Split the work or delay the script |
| Forced reflow | Code reads the page layout right after changing it | Batch reads and writes, or use observers |
A worked example: a slow home page
This example is illustrative, and your numbers will differ. A small business home page scores 62 on mobile. The report shows an LCP of 4.8 seconds, because a 3 MB banner photo loads first. A chat widget and two tracking scripts also add long tasks.
A sensible plan:
- Resize the banner and save it as WebP at about 150 KB. LCP falls first, because the biggest item now loads quickly.
- Delay the chat widget and the trackers until the visitor first touches or scrolls the page.
- Set width and height on every image, so that the layout does not jump.
- Test mobile three times and compare the middle result, because single scores vary.
Our image compression guide covers step one in detail.
Why scores differ between tests
- Lab tests change a little on each run, because of server load and network timing.
- Third-party scripts, such as ads, chat and tags, load differently each time.
- Mobile and desktop use different test settings.
- Field data covers weeks of real visits, while lab data is a single visit.
Run three tests and compare the middle result. Judge your progress over weeks, not from one score.