What the Core Web Vitals are
The Core Web Vitals are three metrics Google uses to measure the real experience of people using a page. They do not measure “how fast everything loads”, but three specific moments: when the important thing appears, when the page responds to a tap, and whether the content moves without warning.
| Metric | What it measures | “Good” target |
|---|---|---|
| LCP (Largest Contentful Paint) | When the largest visible element is shown: an image, a video or a block of text | 2.5 seconds or less |
| INP (Interaction to Next Paint) | How long the page takes to react to clicks, taps and key presses | 200 milliseconds or less |
| CLS (Cumulative Layout Shift) | How much the content shifts unexpectedly | 0.1 or less |
According to web.dev, a page passes when it meets all three targets at the 75th percentile of visits, with mobile and desktop separated. In other words, it has to work well for the great majority of visits, not just on your own computer.
Do they affect rankings?
Google “strongly” recommends achieving good Core Web Vitals and says they align with what its ranking systems seek. But it does not promise a rise in position: it is one part of page experience, alongside other factors.
The practical reason to improve them is simpler: a slow website loses visitors before showing them anything. Also read the guide on how to rank your website on Google to see where speed fits in.
How to measure your website before touching anything
Open PageSpeed Insights and analyse your home page and a service page. Look first at the real user data, if it appears, and then at the lab analysis.
If your website is in Search Console, open the Core Web Vitals report: it groups your URLs by status and by mobile and desktop.
Note the three current values and the page where they are worst.
Change one thing at a time and measure again. If you change ten at once you will not know what worked.
Real data or lab data
The lab simulates a visit; real data comes from actual users and takes time to update. An improvement can take a while to show up in the Search Console report.
How to improve LCP (loading of the main content)
web.dev breaks LCP into four parts: the time to the server’s first byte, the delay until the resource starts loading, the duration of its download and the delay until it is painted. It helps to know which one is yours before optimising.
- Slim down the main image. Match its dimensions to what is actually displayed, and use modern formats and compression.
- Do not lazy-load the main image. web.dev warns that it causes an unnecessary delay; keep that technique for images further down the page.
- Prioritise the key resource. You can mark the likely LCP image with `fetchpriority="high"`, without overdoing it.
- Reduce what blocks painting: heavy CSS and synchronous scripts in the head.
- Improve server response: caching, a content delivery network (CDN) and avoiding chains of redirects.
Mind this: shortening one part can shift the time to another. Compressing an image does little if the problem is a script delaying the paint.
How to improve INP (response to interactions)
INP observes clicks, taps and key presses throughout the whole visit and keeps the worst value (discarding outliers). It does not count scrolling or hovering.
- Reduce the JavaScript that runs on load: fewer plugins, fewer widgets, fewer libraries.
- Review third-party scripts (chat, analytics, pixels, maps): each one competes for the same processor.
- Avoid long tasks. web.dev recommends splitting the work so the browser can respond in between.
- Keep the DOM small: pages with thousands of elements take longer to update.
On WordPress websites, the most common cause is usually an accumulation of plugins and visual builders. Good website maintenance includes reviewing what is surplus.
How to improve CLS (nothing jumps)
CLS measures the largest burst of unexpected shifts during the life of the page. It is that feeling of going to press a button and having it move just beforehand.
- Always specify width and height on images and videos, or reserve the space with `aspect-ratio`.
- Reserve space for ads, cookie banners, embedded videos and anything that loads late.
- Look after web fonts: choose a similar fallback font and preload the critical ones so the swap does not move the text.
- Animate with `transform` instead of changing position or size, because it does not cause shifts.
Where to start if you are short of time
Compress and resize the largest images on the home page.
Remove plugins, scripts and widgets you do not use.
Set dimensions on all images.
Check that the hosting responds well and that caching is in place.
Measure again and repeat with the next page.
There is no need to reach perfection: the aim is to pass the “good” thresholds on the pages that matter most. And remember that a fast website does not replace good content; the two reinforce each other, as the guide on what a business website needs explains.
Frequently asked questions
What loading speed is good?
Google does not set a single total loading time. It uses three metrics: main content visible in 2.5 seconds or less (LCP), response to interactions in 200 milliseconds or less (INP) and visual shift of 0.1 or less (CLS), measured at the 75th percentile of visits.
My website is fine on my computer but poor on PageSpeed. Why?
That is common. Your device and connection are usually better than those of many users, and the lab test simulates a more modest mobile. That is why Google assesses with real user data, separated between mobile and desktop.
Is installing a caching plugin enough?
It helps, especially with server response time, but it does not fix heavy images, third-party scripts or elements that shift. A plugin is just one piece; the improvement usually comes from simplifying the website.
How often should I check these metrics?
After every significant change (a new plugin, a redesign, a banner) and periodically with the Search Console report. Real data takes time to update, so do not expect to see the effect of a change the next day.
Sources6
- web.dev — Web Vitalsweb.dev (opens in a new tab)
- web.dev — Optimize Largest Contentful Paintweb.dev (opens in a new tab)
- web.dev — Interaction to Next Paint (INP)web.dev (opens in a new tab)
- web.dev — Optimize Interaction to Next Paintweb.dev (opens in a new tab)
- web.dev — Optimize Cumulative Layout Shiftweb.dev (opens in a new tab)
- Google Search Central — Core Web Vitals and Google Searchdevelopers.google.com (opens in a new tab)




