Core Web Vitals Explained in Plain English (And How to Fix Each One)
What LCP, INP and CLS actually measure, the usual causes of a bad score, and specific fixes ordered by how much they typically help.

Core Web Vitals sound technical but measure three things any user would recognise: did the page appear quickly, did it respond when I touched it, and did it stop jumping around. Here is what each one really is and what to do about it.
LCP — Largest Contentful Paint
What it measures: how long until the biggest visible element — usually a hero image, a video poster or a large headline — finishes rendering. Target: under 2.5 seconds on mobile.
Common causes of a bad score:
- An enormous, uncompressed hero image.
- The hero image lazy-loaded, so the browser deliberately delays the one thing being measured.
- Render-blocking CSS or fonts in the head.
- Slow server response before any HTML arrives.
- Content rendered only after JavaScript loads and runs.
Fixes, in order of usual payoff:
- Compress and correctly size the hero image, serve a modern format, and give it
fetchpriority="high". Never lazy-load it. - Server-render the above-the-fold content instead of waiting on client JavaScript.
- Preconnect to critical third-party origins and preload the font files you actually use.
- Use
font-display: swapso text is visible while a web font loads. - Put a CDN in front of the site so the first byte arrives fast everywhere.
INP — Interaction to Next Paint
What it measures: how quickly the page visually responds after a tap, click or key press, across the whole visit rather than just the first interaction. Target: under 200 milliseconds.
Common causes: heavy JavaScript on the main thread, expensive event handlers, large component re-renders, and third-party scripts doing work you never asked for.
Fixes:
- Audit third-party scripts ruthlessly. Chat widgets, session recorders and duplicate analytics tags are the most frequent culprits.
- Break up long tasks; anything over 50ms blocks response.
- Defer non-critical JavaScript and load below-the-fold components only when needed.
- Debounce expensive handlers like search-as-you-type.
- Give immediate visual feedback — a pressed state, a spinner — so the interaction feels answered even while work continues.
CLS — Cumulative Layout Shift
What it measures: how much content jumps around after it first appears. Target: under 0.1. This is the one users hate most viscerally, because it makes them tap the wrong thing.
Common causes:
- Images and videos without width and height attributes.
- Ads, embeds and iframes injected into a space that was not reserved.
- Banners, cookie notices and promo bars inserted above existing content.
- Web fonts that swap in at a different size and reflow the text.
Fixes:
- Always set explicit
widthandheight(or a CSS aspect ratio) on every image and video. - Reserve a fixed-height container for anything injected later.
- Overlay banners rather than pushing content down.
- Match your fallback font's metrics to the web font so the swap does not resize text.
Measuring correctly
Two kinds of data exist and they disagree for good reasons. Lab data (a synthetic test run on demand) is repeatable and great for debugging. Field data (real visits from real devices over 28 days) is what actually counts. Optimise using lab tools, but judge success on field data, and be patient — field data updates slowly.
Always test on a throttled mobile connection. A site that feels instant on a desktop with fibre can be painful on a mid-range phone, and the mobile experience is the one that gets measured.
Keeping the wins
Performance regresses quietly. A marketing tag here, an unoptimised image there, and six months later the score is back where it started. Add a performance budget to your deployment process, check the numbers monthly, and treat any new third-party script as a change that must justify its cost. That habit protects the improvements far more effectively than another round of optimisation.


