What are Core Web Vitals?
Core Web Vitals are three measures of real user experience that Google's tools report: Largest Contentful Paint for loading, good at 2.5 seconds or less; Interaction to Next Paint for responsiveness, good at 200 milliseconds or less; and Cumulative Layout Shift for visual stability, good at 0.1 or less. A page passes when all three are good at the 75th percentile of page loads, measured separately on mobile and desktop.
How to fix Core Web Vitals, metric by metric
Find the failing metric
Run the speed test above and read the real-user data first. Work on the poorest of the three metrics, on the device type where it fails.
Split LCP into its four parts
LCP is time to first byte, resource load delay, resource load duration and element render delay. As a guide, the first byte and the download should each take about 40% of it, and each delay under 10%.
Load the LCP image first
Set
fetchpriority="high"on the image most likely to be the LCP element, never lazy load it, and preload it if only CSS or JavaScript refers to it.Cut the wait for the first byte
Remove redirects in front of the page and serve cached HTML from a CDN edge, so the first byte does not wait for the origin server every time.
Find the slow interaction
INP reports the longest interaction in a visit, ignoring outliers. Split each slow one into input delay, processing duration and presentation delay, and fix the largest part.
Free the main thread
Run less JavaScript at load, defer chat, tag and widget scripts until the page is usable, and break long event handlers so the screen can update first.
Reserve space for late content
Give images and videos width and height, reserve room for ads and embeds, and never insert banners above content the visitor is already reading.
Tame web fonts
Match the fallback font's size to the web font, so text does not jump when the font arrives. This matters twice on bilingual sites with Arabic and Latin fonts.
Confirm it in the field
Lighthouse measures LCP and CLS but not INP, for which it uses Total Blocking Time instead. Confirm every fix in real-user data over the following weeks.
The three Core Web Vitals at a glance
Judge each at the 75th percentile of page loads, split by mobile and desktop.
| Metric | What it measures | Good | Common causes of failure |
|---|---|---|---|
| LCP, Largest Contentful Paint | Loading: when the main image or text block appears | 2.5 s or less | Slow first byte, a hero image found late or lazy loaded, a heavy image download |
| INP, Interaction to Next Paint | Responsiveness to clicks, taps and key presses | 200 ms or less; poor above 500 ms | Long JavaScript tasks, heavy event handlers, third party scripts busy at the moment of the tap |
| CLS, Cumulative Layout Shift | Visual stability: how much visible content moves | 0.1 or less; poor above 0.25 | Images and videos without dimensions, ads and embeds that resize, injected content, web fonts |
How each metric is measured
LCP
LCP times the moment the largest image or text block in the viewport is drawn. It is a loading metric, so most of the cure is upstream: a faster first byte and an early, high priority download of the LCP image.
INP
INP observes three kinds of input only: a mouse click, a tap on a touchscreen and a key press on a physical or on-screen keyboard. Scrolling, hovering and zooming are not observed. The value is the longest interaction seen in the visit, with one of the slowest ignored for every 50 interactions, so a single freak pause on a busy page does not decide it. A visit with no clicks, taps or key presses reports no INP at all.
CLS
CLS groups layout shifts into session windows: shifts less than one second apart, in a window of at most five seconds. Each shift scores its impact fraction times its distance fraction, and CLS is the window with the highest total. Shifts within 500 milliseconds of a user input are left out, so a menu that opens when tapped does not count against you.
Who uses this guide
Front end developers
A developer fixes the LCP image priority and the font fallback in a morning, then watches the field data turn over the following weeks.
Teams on a CMS
A team on a theme based site removes unused plugins and widget scripts, which can hold INP back on every page they load.
Online stores
A store works on INP on product pages, where filters, galleries and add to basket buttons run the most script.
Property and hotel sites
Sites with large photo galleries fix LCP and CLS on listing and room pages before anything else.
Marketing teams adding tags
A team adding chat, heatmaps or a new pixel measures INP before and after each one, and removes any that cost more than they return.
Computing students
A student learns how browsers render by changing one thing at a time on a test page and reading which metric moves.
Worked examples
A service page with LCP at 3.4 seconds
Suppose field LCP is 3.4 s. Split it into its four parts. If most of the time passes before the hero image even starts downloading, the image is found late: add fetchpriority="high" and remove any lazy loading from it. If most of the time is the download, resize and compress the image. If the first byte is slow, look at the server and the cache before the page.
A product page with INP at 380 milliseconds
Suppose the slowest interaction is the filter button. If input delay dominates, other scripts were busy when the visitor tapped: defer them. If processing duration dominates, the handler itself is slow: split the work and update the screen first. If presentation delay dominates, the page is re-rendering too much after the click.
A home page with CLS at 0.18
Suppose the shift comes from a promotion banner injected above the hero after load. Reserve its height in the layout from the start, or show it below the content the visitor is reading, and the shift disappears.
Tips for UAE and bilingual sites
Arabic web fonts
Subset Arabic fonts to the characters you use, preload the one the first screen needs, and match the fallback size so right to left text does not shift.
Third party scripts
Chat, tag managers and heatmaps compete for the main thread at the moment of the first tap. Load them after the page is usable.
Hosting near visitors
If most visitors are in the GCC, a server or CDN edge in the region shortens the first byte, which is the first part of LCP.
Test on real phones
A mid-range phone on mobile data tells you more than a laptop on office Wi-Fi. Then check the website speed test for the field view.
Read the score too
Our PageSpeed Insights guide explains the lab score, its weights and why it moves between runs.
What changes in 2027 for Core Web Vitals
Now
- INP became a stable Core Web Vital (2024), replacing First Input Delay; LCP, CLS and INP are the three stable metrics today.
- Chrome changes the definitions of stable Core Web Vitals no more than once a year, and a candidate metric stays pending for at least six months before it can become stable.
- Field data comes from the Chrome User Experience Report, which feeds Chrome DevTools, PageSpeed Insights and the Search Console Core Web Vitals report; the web-vitals JavaScript library measures all three in production.
Next
- AdEngage UAE expects responsiveness, not loading, to be where most UAE sites fall short in 2027, because every new widget adds work at the moment of the tap.
- Any change to the stable set will be visible in advance: a new metric spends at least six months as pending first, so watch the pending list.
- Set a performance budget for every release, so each new script has to earn its place before it ships.