Skip to main content
PerformanceSEOWeb Development

Core Web Vitals Explained: What Is CLS, LCP and INP, and How to Pass Them

Web Maestro TeamUpdated 12 min read
Core Web Vitals Explained: What Is CLS, LCP and INP, and How to Pass Them

A slow website costs you twice: visitors leave before they see your offer, and search engines have less reason to show you. Google measures real-world page experience with three metrics called Core Web Vitals. This guide explains what they mean, how to measure them and which fixes usually make the biggest difference.

Key takeaways

  • Core Web Vitals measure loading (LCP), responsiveness (INP) and visual stability (CLS).
  • CLS is a unitless score for unexpected movement of content; 0.1 or less is good.
  • Google's "good" thresholds are LCP 2.5 s or less, INP 200 ms or less and CLS 0.1 or less, measured at the 75th percentile of real visits.
  • Images, JavaScript and hosting are the most common causes of slow pages.
  • Speed is part of user experience; it helps conversions as well as SEO.

What are the 3 types of Core Web Vitals?

There are three Core Web Vitals, one for each part of the experience: loading (LCP), responsiveness (INP) and visual stability (CLS). Google assesses each one at the 75th percentile of real visits, separately for mobile and desktop, so at least three out of four visits must be "good" for the page to pass.

MetricMeasuresGoodNeeds improvementPoor
LCP (Largest Contentful Paint)Loading2.5 s or less2.5 s to 4 sover 4 s
INP (Interaction to Next Paint)Responsiveness200 ms or less200 ms to 500 msover 500 ms
CLS (Cumulative Layout Shift)Visual stability0.1 or less0.1 to 0.25over 0.25

INP replaced First Input Delay (FID) as a Core Web Vital in March 2024. Older guides that still mention FID are out of date.

Largest Contentful Paint (LCP): loading

LCP is the time it takes for the largest visible element, usually a hero image or a main heading, to appear. A good LCP is 2.5 seconds or less. It is the metric most affected by image size, server speed and render-blocking resources.

Interaction to Next Paint (INP): responsiveness

INP measures how quickly the page responds when a user taps, clicks or types. A good INP is 200 milliseconds or less. Heavy JavaScript running on the main thread is the usual cause of poor scores.

What is CLS in Core Web Vitals?

CLS (Cumulative Layout Shift) is the Core Web Vital that measures visual stability: how much visible content moves unexpectedly while the page is open. A good CLS score is 0.1 or less, 0.1 to 0.25 needs improvement, and above 0.25 is poor. Think of a button that jumps just as you tap it, or text that slides down when an image loads above it.

High CLS is mostly caused by images without dimensions, late-loading fonts, and ads, embeds or banners injected above content.

How is the CLS score calculated?

CLS is a score, not a time, and it has no unit. Each unexpected shift gets a score:

layout shift score = impact fraction × distance fraction

  • Impact fraction: how much of the screen the moving element touches, before and after it moves, combined.
  • Distance fraction: how far it moved, as a share of the screen's largest dimension.

Shifts are then grouped into "session windows": shifts less than 1 second apart belong to the same window, and a window lasts at most 5 seconds. The page's CLS is the window with the highest total, not the sum of every shift during the visit. Shifts within half a second after a tap, click or key press do not count, because the user expected them, such as opening a menu.

A quick example: a cookie banner loads late and pushes a block that fills half the screen down by a quarter of the screen height. The area affected covers about 75% of the screen and the distance is 25%, so that single shift scores 0.75 × 0.25 ≈ 0.19, already in the "needs improvement" range on its own.

How to find what is shifting

  • PageSpeed Insights: the "Avoid large layout shifts" diagnostic lists the elements that moved.
  • Chrome DevTools: record the page in the Performance panel and look at the layout shift entries; each one highlights the element that moved.
  • Search Console: the Core Web Vitals report groups URLs with CLS issues from real visits, so you can fix a whole template at once.

How to fix CLS

  • Give every image, video and iframe a width and height (or a CSS aspect-ratio) so the browser reserves space before it loads.
  • Reserve fixed space for ads, embeds and banners, and show cookie or promo bars as overlays instead of pushing content down.
  • Load web fonts with a matching fallback (font-display plus size-adjust) so text does not jump when the font arrives.
  • Do not insert content above what the user is reading unless they asked for it, for example after a tap.
  • Animate with transform and opacity rather than properties that change layout such as top or height.

Why lab CLS and real CLS can differ

Lighthouse and the lab part of PageSpeed Insights only watch the page while it loads, without scrolling or tapping. Real visitors scroll, open tabs, load more items and wait for late banners, so field CLS in Search Console or the "real users" part of PageSpeed Insights is often higher. If your lab CLS is 0 but the field data says "needs improvement", look for shifts that happen after load: sticky headers that change height, lazy-loaded ads, "load more" lists and consent bars that appear a few seconds in.

How to measure

  • PageSpeed Insights shows both lab data (Lighthouse) and, when available, field data from real Chrome users.
  • Google Search Console has a Core Web Vitals report that groups your URLs into good, needs improvement and poor.
  • Lighthouse in Chrome DevTools helps you test changes locally. Test with mobile settings, because that is where most problems show up.

Field data from real visitors is what Google uses; lab tests are for finding and fixing problems.

The fixes that matter most

1. Optimize images

Images are usually the largest files on a page. Resize them to the size they are displayed, compress them, and use modern formats such as WebP or AVIF. Add explicit width and height attributes so the browser reserves space, lazy-load images below the fold, and never lazy-load the main hero image.

2. Ship less JavaScript

Every script has to be downloaded, parsed and executed. Remove libraries you do not need, split code so each page loads only what it uses, and defer third-party scripts such as chat widgets and analytics until after the page is usable. Static or server-rendered pages with minimal client-side code are the fastest approach for marketing sites, which is why we build our own pages that way.

3. Use good hosting and a CDN

A fast first byte makes every other metric easier. Host close to your visitors or behind a content delivery network, enable HTTP/2 or HTTP/3 and compression (Brotli or gzip), and cache static assets for a long time with versioned file names.

4. Handle fonts carefully

Use only the font weights you need, serve fonts from your own domain or preload them, and use font-display: swap so text is visible immediately. For Arabic and English sites, load the Arabic font only on Arabic pages.

5. Prevent layout shift

Give images, videos and embeds fixed dimensions or an aspect ratio, reserve space for banners and ads, and avoid inserting content above what the user is already reading.

6. Keep your database and plugins lean

On CMS sites, slow queries and too many plugins are frequent culprits. Remove unused plugins, cache pages, and keep software updated.

Diagnosing a slow page step by step

Do not guess; follow the evidence. Run PageSpeed Insights on the mobile tab and read the field data first. If LCP is poor, open the diagnostics and identify the LCP element: it is usually an image or a large heading. Check how large that file is, whether it is lazy-loaded by mistake, and whether anything blocks it, such as a heavy stylesheet or a script in the head. If INP is poor, record a Performance trace in Chrome DevTools while tapping the slow control and look for long tasks. If CLS is poor, enable layout shift highlighting and see which elements jump. Fix one cause at a time and re-test, so you know what worked.

Third-party scripts: the hidden cost

Chat widgets, tag managers, heat maps, social embeds and ad pixels each add network requests and main-thread work, and you do not control their code. Audit them regularly: remove anything nobody uses, load the rest after the page is interactive, and prefer lightweight alternatives. For videos, show a thumbnail and load the player only when the visitor clicks. For maps, use a static image until interaction. These small changes often improve INP and LCP more than any server upgrade.

Set a performance budget

A performance budget is a limit you agree not to exceed, for example a maximum size for images on a page or a maximum amount of JavaScript. When every new feature must fit inside the budget, speed stops being a one-off project and becomes a habit. Write the limits down, check them before each release and decline additions that break them unless something else is removed.

Why static and server-rendered pages are fast

When a page is prepared in advance and served from a CDN, the browser receives ready HTML immediately and needs little JavaScript to show it. Client-side rendering, by contrast, sends a nearly empty page and builds the content in the browser, which delays LCP and uses more CPU on phones. For marketing sites, blogs and service pages, pre-rendered HTML with small, targeted scripts for interaction is usually the best balance of speed, SEO and simplicity. Dynamic features such as dashboards and carts can still load their code only where needed.

Mobile testing tips for Jordan and the region

  • Test on a mid-range Android phone, not only on a fast laptop, since many visitors use such devices.
  • Throttle the network in DevTools to a slower mobile profile to see what a typical visitor experiences.
  • Test the Arabic pages separately, because fonts and right-to-left layout can affect both loading and stability.
  • Check pages after consent banners and chat widgets load, as these often cause shifts.

Speed and conversions

Speed is not only a ranking factor. A page that responds quickly feels more professional, reduces abandonment on mobile and makes forms and checkouts easier to complete. Treat performance as part of your product, and re-test after every significant change.

Quick wins you can finish in one day

  1. Convert your largest images to WebP and resize them to the dimensions they are displayed at.
  2. Add width and height to every image and video so the layout does not jump.
  3. Remove any plugin, script or font weight that nothing uses.
  4. Preload the main hero image and the primary font, and lazy-load everything below the fold.
  5. Turn on compression and long-term caching for static files at your host or CDN.
  6. Move chat widgets, analytics and similar scripts so they load after the page is usable.
  7. Re-test on mobile and write down the before and after numbers so you can see what each change achieved.

Real results vary by site, which is why recording numbers matters. If a change does not help, undo it and try the next one rather than stacking guesses.

A simple performance routine

  1. Test your key pages on mobile with PageSpeed Insights.
  2. Fix the largest issue first, usually images or JavaScript.
  3. Re-test, and repeat.
  4. Check the Search Console report monthly.
  5. Run a test after adding any new script, plugin or large image.

Frequently asked questions

What is a good CLS score?

0.1 or less, for at least 75% of real visits, on mobile and on desktop. Between 0.1 and 0.25 needs improvement, and above 0.25 is poor.

Can CLS be 0?

Yes. A page that reserves space for every image, embed and banner, and loads fonts with a matching fallback, can have a CLS of 0 or very close to it. Zero is not required; anything up to 0.1 passes.

What does CLS stand for?

Cumulative Layout Shift. "Layout shift" is visible content moving from one position to another, and "cumulative" means the shifts in the worst burst during the visit are added together.

Are Core Web Vitals a ranking factor?

Yes, page experience signals, including Core Web Vitals, are used by Google in ranking. They are one factor among many, and content relevance remains the most important, but a poor experience can hold a good page back.

What is a good PageSpeed score?

The score is a lab estimate; the real goal is passing the three Core Web Vitals thresholds for real users. A high score is a helpful indicator, not the target by itself.

Why is my site slow only on mobile?

Phones have less processing power and often slower connections, so large images and heavy JavaScript hurt much more. Always test with mobile settings.

Can I fix this myself?

Image compression and removing unused plugins are accessible to most site owners. Deeper issues in code and infrastructure usually need a developer.

How often should I test speed?

Test your key pages after every significant change and review the Search Console report at least monthly, since new scripts, plugins and images can quietly slow a site down.

Does a CDN make a site fast by itself?

A CDN helps with delivery time, but it cannot fix oversized images, heavy JavaScript or slow server code. Use it together with the other fixes in this guide.

What happened to FID?

First Input Delay only measured the delay before the first interaction. Google replaced it with INP in March 2024 because INP looks at every interaction during the visit, which reflects real responsiveness much better.

What a Core Web Vitals optimization service includes

If you would rather hand the work to a team, a proper Core Web Vitals service should follow evidence, not a checklist. This is how we approach it:

  1. Audit with field data: read the Search Console report and real-user data first, then reproduce each problem in lab tests on mobile settings.
  2. A prioritized fix list: the LCP element, render-blocking files, heavy scripts and layout shifts, ordered by impact on your most important pages.
  3. Implementation: image pipeline, code splitting, font loading, caching and hosting changes, or a rebuild on a static or server-rendered stack when the platform itself is the bottleneck.
  4. Verification: before and after numbers for every change, then a check of the field data once Google has collected about 28 days of new visits.

Be wary of anyone who guarantees a specific score or ranking. Scores depend on your content, your third-party tools and your visitors' devices, so honest work reports measured results instead of promises.

Next step

Want to know how your site performs? Read about our web development and hosting and DevOps services, or ask for a speed review.

Have a digital project?Ask for a speed audit

How would you like to reach us?

Pick whatever is easiest. The team will get back to you directly.

Call us now+962 789 123 421WhatsAppMessage us directlyNot sure where to start?Take a 2-minute guided tour and get a free starting plan