Core Web Vitals get discussed mostly as an SEO issue. They are a modest ranking signal, which is true but beside the point. The more useful reason to care is that they measure things that directly cost you customers: how long someone stares at a blank screen, whether the page responds when they tap, and whether the button moves just as they reach for it.

The three metrics

Largest Contentful Paint (LCP)

Measures: how long until the largest visible element renders — usually a hero image, a heading or a video poster.

Target: under 2.5 seconds.

In plain terms: how long the visitor stares at nothing.

Interaction to Next Paint (INP)

Measures: how quickly the page visually responds to user interactions, across the whole visit.

Target: under 200 milliseconds.

In plain terms: whether taps and clicks feel instant or laggy. It replaced First Input Delay and is considerably stricter, because it measures every interaction rather than only the first.

Cumulative Layout Shift (CLS)

Measures: how much visible content moves around unexpectedly during loading.

Target: under 0.1.

In plain terms: whether the thing you were about to tap jumps somewhere else.

Measure properly

Two kinds of data, and the distinction matters.

Lab data comes from a simulated load — Lighthouse, PageSpeed Insights' lab section. Useful for debugging because it is repeatable, and misleading as a measure of reality because it runs on one device under one network condition.

Field data comes from real visits, aggregated in the Chrome User Experience Report. It reflects actual users on actual phones on actual networks. This is what Google uses.

The gap between them is routinely large. A site scoring well in Lighthouse on a developer's laptop can fail in the field, where visitors are on mid-range Android phones over mobile data. Trust the field data.

Find it in Search Console under Core Web Vitals, or in the top section of PageSpeed Insights.

Fixing LCP

Work through in this order; the first two account for most problems.

Images. Nearly always the cause.

  • Serve modern formats — WebP or AVIF
  • Size them for the actual display dimensions. A 3000px image displayed at 800px wastes most of its bytes.
  • Use responsive sizes so phones get phone-sized images
  • Do not lazy-load the hero image. Lazy loading the LCP element delays the thing you are trying to speed up — a surprisingly common own goal.
  • Preload the hero image so it starts downloading immediately

Render-blocking resources. CSS and synchronous JavaScript in the head stop the page rendering until they load. Inline the critical CSS, defer the rest, and move scripts out of the blocking path.

Server response time. If the server takes a second to respond, you have lost a second before anything else can happen. Static generation effectively eliminates this — the server just hands over a file.

Fonts. Web fonts can delay text rendering entirely. Use font-display: swap, preload the fonts you actually use above the fold, and subset them to the characters you need.

Fixing INP

INP problems come from JavaScript occupying the main thread when the user wants to interact.

Reduce how much JavaScript you ship. The most effective fix and the least popular. Audit the bundle. Every third-party script, every library imported for one function, every analytics tag — each costs main-thread time.

Break up long tasks. Anything running over 50 milliseconds blocks interaction. Split work into chunks and yield between them.

Defer non-essential work. Analytics, chat widgets, tracking pixels and consent tools do not need to run before the user can interact. Load them after.

Watch hydration. Framework-heavy pages can download fast and still feel unresponsive while the JavaScript attaches behaviour. Server components and partial hydration reduce this.

Fixing CLS

Almost always about space not being reserved for things that load late.

Set explicit width and height on every image and video. The browser then reserves the correct space before the file arrives. This single change fixes the majority of CLS problems.

Give embeds and ads fixed containers. An ad slot that collapses to zero and then expands pushes everything down.

Never insert content above existing content. Cookie banners and promotional bars that appear after load and push the page down are a common cause. Overlay them, or reserve their space from the start.

Handle font swaps carefully. A large difference between the fallback and the web font causes reflow. Match fallback metrics where you can.

Where most of the damage comes from

After enough audits, the pattern is consistent. Two causes dominate:

  1. Images — unoptimised, oversized, wrong format, lazy-loaded when they should not be
  2. Third-party scripts — analytics, tag managers, chat widgets, heatmaps, ad pixels, each loading more scripts

Fixing those two usually moves all three metrics further than any framework-level work. It is also, inconveniently, organisational rather than technical: removing a marketing tag requires someone to agree to lose it.

Audit your third-party scripts annually. There is almost always something installed for a campaign two years ago that nobody has looked at since.

A realistic order of work

  1. Get field data from Search Console and find which metric fails, on which pages
  2. Fix images on the worst-performing templates
  3. Audit third-party scripts and remove or defer what you can
  4. Set dimensions on everything that loads late
  5. Address render-blocking CSS and fonts
  6. Re-measure after four weeks — field data lags, so do not expect instant confirmation

That last point catches people. Field data is a 28-day rolling window, so a fix shipped today shows up gradually. Use lab tools for immediate confirmation that a change worked, and field data to confirm it mattered.

Keeping it fixed

Performance regresses. Someone adds a script, uploads a large image, installs a plugin. The way to hold a gain is to make it a constraint rather than a project: set a performance budget and enforce it in your build pipeline, so a regression fails the build rather than reaching production.

If you want an audit that identifies the specific causes on your site rather than a generic score, get in touch.