Skip to content
Derar Sattouf

Core Web Vitals in 2026: Fixing LCP, INP and CLS in Next.js

Updated Performance

Core Web Vitals in 2026: Fixing LCP, INP and CLS in Next.js

Core Web Vitals are the three user-experience metrics Google uses as part of its ranking systems: how fast the main content appears, how quickly the page responds to input, and how much the layout jumps around while loading. For a Next.js site, they are also the place where framework choices show up in real numbers. Hydration cost, font loading, image sizing, and client-side widgets all land in these metrics.

The three metrics are LCP (Largest Contentful Paint), INP (Interaction to Next Paint) and CLS (Cumulative Layout Shift). INP replaced First Input Delay in March 2024. A metric is judged at the 75th percentile of real visits, so a lab score from a single test run doesn't decide your status. The good thresholds are LCP at 2.5 seconds or less, INP at 200 milliseconds or less, and CLS at 0.1 or less.

Google says there is no single "page experience" ranking signal, that its ranking systems use Core Web Vitals, and that good scores do not guarantee top rankings. Treat them as a quality floor, not a shortcut.

Common Next.js regressions come from three sources: an unsized or late-loading hero image, a font or embed that shifts the layout, and too much client JavaScript competing with user input. Measure field data with the Search Console report, the Chrome UX Report and your own reporting endpoint. Use Lighthouse and the Performance panel to explain a problem, not to grade it.

I worked through these trade-offs on Toothpick, a multi-tenant Next.js storefront that mixes server rendering with static generation and enforces performance budgets.

What the metrics measure and the 2026 thresholds

Google's guidance on the three metrics is consistent with the thresholds below. Each is evaluated at the 75th percentile, which means at least three out of four page loads (or interactions, for INP) must meet the "good" bound for a page or origin to pass.

MetricWhat it measuresGoodNeeds improvementPoor
LCPTime until the largest visible content element renders2.5 s or less2.5 s to 4 sOver 4 s
INPLatency from a user interaction to the next visual update, across the page visit200 ms or less200 ms to 500 msOver 500 ms
CLSSum of unexpected layout shifts during the page's lifetime0.1 or less0.1 to 0.25Over 0.25

Three details trip people up.

INP is not FID. First Input Delay measured only the delay before the browser began handling the first interaction. INP looks at every click, tap, and key press during the visit, and reports a value close to the slowest one. A page with a fast first click and a sluggish filter menu can pass FID and fail INP. Google made INP a Core Web Vital on March 12, 2024, so any older article that talks about FID is out of date.

The 75th percentile is the target, not the average. A page with a great median experience can still fail if a quarter of visits are slow. Mobile users on mid-range phones are usually the group that pulls the percentile up.

The thresholds are set on real-user data. web.dev explains they were chosen to be achievable on real sites, using Chrome User Experience Report data. A perfect LCP of zero is not a goal, because network and device latency make it impossible.

Search ranking: what Google says

Keep the ranking claim precise, because it is easy to overstate. Google's Search Central documentation describes page experience as a set of signals, and says there is no single page experience ranking signal. Core Web Vitals are the part of that set that Google explicitly says its ranking systems use. Google's 2023 Search blog post on page experience also describes Core Web Vitals as signals that its core ranking systems consider, alongside other signals such as HTTPS.

The practical reading is this:

  • Good Core Web Vitals will not rescue thin or irrelevant content. Relevance and helpfulness still carry most of the weight.
  • Poor Core Web Vitals can hold a page back when it competes with an otherwise similar page that performs better.
  • Google also says that good results in the Search Console report or in third-party tools do not guarantee top rankings.

So the goal is to fix real user pain, which also happens to satisfy the ranking signal. Chasing a green number in a lab tool does not do that.

Field data versus lab data

This distinction matters more than any individual fix.

Lab data is a synthetic test run in a controlled environment: one device profile, one network profile, one page load, usually triggered by you. Lighthouse and PageSpeed Insights (in its lab section) are lab tools. Lab data is repeatable, which makes it good for regression testing and for explaining a problem. It is poor at predicting what real users experience, because it does not include their devices, their extensions, their networks, or the interactions they actually perform. Lighthouse also does not measure INP directly in a standard page-load run, so you need to script interactions or use a timespan recording to see it.

Field data is what real Chrome users experienced. It is aggregated over a rolling window (third-party guides commonly describe 28 days for the Chrome UX Report). There are three places to see it:

  1. Google Search Console, Core Web Vitals report. The closest thing to the ranking view. It groups URLs into good, needs improvement, and poor.
  2. The Chrome UX Report (CrUX). The public dataset behind much of the field data, queryable through the CrUX API or PageSpeed Insights.
  3. Your own reporting endpoint. Using the web-vitals library or Next.js's useReportWebVitals hook, you can send each metric from your own visitors. This is the only option that covers low-traffic pages CrUX ignores, and it lets you segment by route and device.

The rule of thumb is simple: use field data to decide whether something is a problem, lab data to find out why, and your reporting endpoint to confirm that a fix worked on your own traffic.

Fixing LCP in a Next.js app

LCP is usually one element: the hero image, a large heading, or a background image on the first screen. The fixes are about making that element available early and making its size known before it arrives.

Make the hero image high priority

next/image lazy loads images by default, which is the right behavior for most images and the wrong behavior for the LCP element. Tell the browser the hero is important and give it an explicit size so it can reserve space.

Next.js 16 changed the API. The old priority prop is deprecated in favor of a preload prop that states what it does (insert a preload link in the document head). The Next.js docs also say that in most cases you should use loading="eager" or fetchPriority="high" rather than preload, and that you should not combine preload with those props.

// Next.js 16: hero image that is the LCP element
import Image from "next/image";

export function Hero() {
  return (
    <Image
      src="/images/blog/63.webp"
      alt="Abstract illustration of a performance dashboard"
      width={1200}
      height={630}
      sizes="(max-width: 768px) 100vw, 1200px"
      fetchPriority="high"
      loading="eager"
    />
  );
}

If the image is discovered late (for example it is rendered by a client component after data loads) and you want the browser to start fetching it from the head, use preload instead:

<Image src="/hero.webp" alt="" width={1200} height={630} preload />

On Next.js 15 and earlier, use priority (<Image priority ... />). If you are upgrading, search your codebase for priority on Image components and migrate them; see Next.js upgrade and security checklist.

Mark one or two images per page at most. Marking many images as high priority forces the browser to fetch them all at once and competes with the real LCP element. Avoid preload when several different images could be the LCP element depending on viewport size (for example separate mobile and desktop heroes).

If you use fill, make sure the parent has an explicit height or aspect ratio, or the image will collapse and the layout will shift later.

Keep fonts from delaying text

When the LCP element is text, the browser may wait for a web font before it can paint. next/font self-hosts the font files at build time, which removes a third-party request and avoids most of the layout shift that comes from late font swaps. Set display explicitly so you know what happens while the font loads.

// Illustrative example: a font definition in a Next.js project
import { Inter } from "next/font/google";

export const bodyFont = Inter({
  subsets: ["latin"],
  display: "swap",
  variable: "--font-body",
});

swap shows fallback text immediately and replaces it when the font arrives. That favors LCP, at the cost of a possible small shift, which you can reduce with adjustFontFallback and a fallback font with similar metrics. optional avoids the swap entirely for text that is not critical. Check the current next/font documentation for the defaults in your version before relying on them, because the defaults have changed over time.

If your project loads fonts through a design system or a wrapper instead of a direct next/font call, check that the font you ship is loaded with a display strategy you have chosen on purpose.

LCP also includes time to first byte. If the hero waits on a slow server-side data fetch, no image optimization will fix it, so move non-critical data out of the critical path and use streaming with loading.tsx or Suspense.

Fixing CLS: reserve space before content arrives

CLS is almost always caused by content that loads without a reserved size. The fix is to tell the browser the size before the content exists.

Images. Always pass width and height to next/image, or use fill inside a container with a fixed aspect ratio. This lets the browser calculate the box before the file arrives.

Embeds. Third-party iframes, video players, maps, and comment widgets are common sources of shift. Wrap them in a container with a fixed aspect-ratio or a minimum height.

// Illustrative example: reserving space for an embed
export function VideoEmbed({ src, title }: { src: string; title: string }) {
  return (
    <div style={{ position: "relative", width: "100%", aspectRatio: "16 / 9" }}>
      <iframe
        src={src}
        title={title}
        loading="lazy"
        style={{ position: "absolute", inset: 0, width: "100%", height: "100%", border: 0 }}
        allowFullScreen
      />
    </div>
  );
}

Late-inserted banners and cookie notices. A banner that pushes content down after load is one of the most common CLS causes. Overlay it on top of the page, or reserve its height in the layout.

Client-side fetched content. When a component fetches data after mount, use a skeleton with the same dimensions as the final content.

Reducing JavaScript on the main thread for INP

INP is a main-thread problem. When the browser is busy running JavaScript for hydration, a timer, a large state update, or a third-party script, a click cannot be handled until that work finishes. Reducing the amount of JavaScript that runs on the client, and splitting what remains into smaller tasks, is the most effective INP fix for most Next.js sites.

Keep components on the server when they do not need the browser

In the App Router, components are Server Components by default. A Client Component ships its code to the browser and hydrates it. Add "use client" only to the part of the tree that needs state, effects, or browser APIs. A common pattern is a server-rendered page that imports one small client component for an interactive control.

// Illustrative example: keep the page on the server, move only the interaction to the client
// app/blog/page.tsx (Server Component)
import { SearchFilter } from "@/components/SearchFilter"; // "use client" inside this file
import { getPosts } from "@/lib/posts";

export default async function BlogPage() {
  const posts = await getPosts();
  return (
    <>
      <SearchFilter />
      <ul>
        {posts.map((post) => (
          <li key={post.slug}>{post.title}</li>
        ))}
      </ul>
    </>
  );
}

The list of posts never ships as client code, so hydration has less to do before the page becomes responsive.

Pass only the fields a Client Component needs, because props are serialized into the HTML and hydrated.

Load heavy widgets lazily

Charts, editors, maps, and syntax highlighters are often large and rarely needed on first paint. Use next/dynamic to split them into separate chunks, and reserve their space so the page does not shift when they arrive.

// Illustrative example: lazy loading a heavy chart in a Client Component
"use client";

import dynamic from "next/dynamic";

const RevenueChart = dynamic(() => import("@/components/RevenueChart"), {
  ssr: false,
  loading: () => <div style={{ height: 320 }} aria-hidden="true" />,
});

export function Dashboard() {
  return <RevenueChart />;
}

Load the chart only after the user needs it when possible, for example when a tab is opened, not when the page mounts.

Break up long tasks

Any task that runs for 50 ms or more is a long task, and it can delay input for that duration. Break long loops into chunks and yield back to the browser between them. Also avoid heavy work inside input handlers: update the UI first with the minimal state change, then defer the expensive part.

// Illustrative example: yield to the browser between chunks of work
export async function processInChunks<T>(items: T[], handle: (item: T) => void, chunkSize = 50) {
  for (let i = 0; i < items.length; i += chunkSize) {
    items.slice(i, i + chunkSize).forEach(handle);
    await new Promise((resolve) => setTimeout(resolve, 0));
  }
}

Audit third-party scripts

Tag managers, chat widgets, and A/B testing scripts all run on the main thread. Load them with next/script using a strategy that matches their importance, and remove the ones that no longer earn their cost.

Diagnosing slow interactions

When INP is poor in field data, you need to find the specific interaction that is slow. Two tools do most of the work.

The web-vitals attribution build. The web-vitals library (current major version 5 at the time of writing) has an attribution build, imported from web-vitals/attribution, that adds diagnostic detail to each metric. For INP the attribution includes interactionTarget (a selector for the element), interactionType, and the three subparts inputDelay, processingDuration and presentationDelay. When the browser supports it, it also includes longAnimationFrameEntries, the Long Animation Frame records that overlap the interaction, which point at the scripts responsible. Log these fields from real users, group them by interactionTarget, and you will usually find one or two interactions responsible for most of the bad values.

The Performance panel. Reproduce the slow interaction in Chrome DevTools:

  1. Open the Performance panel and start recording.
  2. Perform the interaction, such as opening a menu or submitting a filter.
  3. Stop recording and find the Interaction track or the event marked with the input type.
  4. Look at the three phases: input delay (time before the handler starts), processing time (your event handlers and any synchronous work they trigger), and presentation delay (rendering and layout after the handler). Each points to a different fix.

If input delay is high, the main thread was busy before the click, usually because of hydration or a long task from another script. If processing time is high, look at your handler and whatever state updates it triggers. If presentation delay is high, the browser is spending long on style and layout, often because the update touches a large part of the DOM.

Remember that lab interactions only help if they mirror what users do. A test that clicks one button on an empty page will not reproduce a slow filter on a list of two hundred items.

LCP is four phases, not one number

LCP can be split into subparts, and each points at a different fix. Look at the breakdown in DevTools (Performance panel, Insights) or in the attribution build of web-vitals before you change anything.

SubpartWhat it coversIf it is large, look at
Time to first byteNavigation start to the first byte of HTMLSlow server rendering or data fetches, no caching, distant region, redirects. See Next.js caching and data patterns
Resource load delayFirst byte to the start of loading the LCP resourceThe image is discovered late (client-rendered, CSS background, lazy attribute). Make it discoverable in the HTML and high priority
Resource load durationTime to download the LCP resourceFile too large, wrong format, no CDN, wrong sizes so a huge variant is chosen
Element render delayResource finished to the element paintedRender-blocking CSS or JavaScript, main thread busy, font still loading for a text LCP

A text-diagram of a healthy page:

navigation start
  |-- TTFB ----------|-- load delay --|-- load duration --|-- render delay --|
  0                 600ms            800ms              1300ms            1500ms
                                                                      LCP = 1.5 s

Most pages that fail LCP are dominated by one of the four. Fix the largest first, then re-measure.

INP in depth: where the time goes

INP measures the full path from a user's input to the next frame being painted. Three phases:

  1. Input delay. The browser could not start your handler because the main thread was busy (hydration, a long task, a timer).
  2. Processing duration. Your event handlers and any synchronous work they trigger (React state updates that re-render large trees, expensive computations).
  3. Presentation delay. The browser computing style, layout and paint after your handler finished.

Fixes by phase:

PhaseTypical cause in Next.jsFix
Input delayHydration of a big client tree; third-party scripts; other long tasksShrink the client bundle, move work to Server Components, load scripts later with next/script, split long tasks
ProcessingA handler that filters or sorts thousands of items synchronously, or triggers a large re-renderMark the update as a transition, debounce, memoize (the React Compiler helps), virtualize the list
PresentationHuge DOM, expensive CSS selectors, layout thrashingReduce DOM size, use content-visibility: auto on long off-screen sections, avoid reading layout right after writing

Lab: fix a slow filter

The symptom: typing in a search box over 5,000 items feels laggy and INP on that page is 400 ms.

Before, every keystroke re-renders the whole list synchronously:

"use client";
import { useState } from "react";

export function SlowFilter({ items }: { items: string[] }) {
  const [query, setQuery] = useState("");
  const visible = items.filter((i) => i.toLowerCase().includes(query.toLowerCase()));

  return (
    <>
      <input value={query} onChange={(e) => setQuery(e.target.value)} />
      <ul>
        {visible.map((i) => (
          <li key={i}>{i}</li>
        ))}
      </ul>
    </>
  );
}

After, the input stays responsive because the expensive list update is a low-priority transition:

"use client";
import { useDeferredValue, useMemo, useState } from "react";

export function FastFilter({ items }: { items: string[] }) {
  const [query, setQuery] = useState("");
  const deferredQuery = useDeferredValue(query);

  const visible = useMemo(() => {
    const q = deferredQuery.toLowerCase();
    return items.filter((i) => i.toLowerCase().includes(q));
  }, [items, deferredQuery]);

  return (
    <>
      <input value={query} onChange={(e) => setQuery(e.target.value)} />
      <ul>
        {visible.map((i) => (
          <li key={i}>{i}</li>
        ))}
      </ul>
    </>
  );
}

useDeferredValue lets React update the input immediately and render the list from the deferred value when it has time, interrupting that render if more typing arrives. For a very long list, also virtualize it (render only visible rows) so presentation delay does not stay high. With the React Compiler enabled, the manual useMemo is usually unnecessary.

Verify the fix: record before and after in the Performance panel, confirm the interaction's processing duration dropped, then watch field INP for that route.

Yielding in your own code

For work that is not a React render, yield explicitly. Where supported, scheduler.yield() lets other tasks, including input, run between chunks. Feature-detect it and fall back to a timeout:

async function yieldToMain() {
  const sched = (globalThis as { scheduler?: { yield?: () => Promise<void> } }).scheduler;
  if (sched?.yield) return sched.yield();
  return new Promise<void>((resolve) => setTimeout(resolve, 0));
}

export async function processLarge<T>(items: T[], handle: (item: T) => void) {
  let last = performance.now();
  for (const item of items) {
    handle(item);
    if (performance.now() - last > 40) {
      await yieldToMain();
      last = performance.now();
    }
  }
}

Check browser support for scheduler.yield before relying on it; the fallback keeps the code working everywhere.

Move non-urgent server work after the response

On the server side, analytics, logging and cache warming should not delay the response. Next.js provides after() from next/server to schedule work after the response finishes. That helps TTFB and therefore LCP:

// app/api/track/route.ts
import { after } from "next/server";

export async function POST(request: Request) {
  const event = await request.json();
  after(async () => {
    // write to your analytics store without blocking the response
    await saveEvent(event);
  });
  return new Response(null, { status: 202 });
}

declare function saveEvent(event: unknown): Promise<void>;

Back/forward cache and prefetching

Two features can make navigations feel instant, and both interact with Web Vitals.

  • Back/forward cache (bfcache). Pages restored from bfcache load almost instantly. Things that block it include unload handlers, open connections in some cases, and Cache-Control: no-store on the main document in some browsers. Test in Chrome DevTools (Application panel, Back/forward cache). Real-user metrics from restores are reported with navigationType of back-forward-cache, which your reporter should segment so it does not skew averages.
  • Prefetching and prerendering. next/link prefetches routes in production, and the browser's Speculation Rules API can prerender likely next pages. Prerendered pages count their LCP from activation, which can make LCP look excellent, but be careful that analytics and side effects do not fire early. See speculation rules for instant navigation.

Symptom to fix cheat sheet

SymptomMetricFirst thing to check
Hero image appears lateLCPIs it lazy loaded or discovered late? Is the file large?
Headline appears lateLCPFont loading, server data wait, render-blocking CSS
Layout jumps when ad or embed loadsCLSReserve space with aspect-ratio or fixed height
Content jumps when fonts loadCLSnext/font, fallback font metrics
Menu opens slowlyINPHydration, handler work, re-render size
Typing lags in a search boxINPHeavy synchronous filtering, big lists
Passes in lab, fails in fieldAllMobile devices, slow networks, third-party scripts, real interactions
Good on desktop, poor on mobileAllCPU-bound work, large images, JavaScript size
Regressed after a releaseAllCompare bundle size, new third-party tag, changed image or font

Wiring up web vitals reporting in Next.js

Field data from your own visitors is the most useful signal for a site your size. Next.js provides the useReportWebVitals hook from next/web-vitals. In the App Router, the hook must be called from a Client Component, so the usual pattern is a small reporter component mounted in the root layout.

The example below uses a track helper from an analytics module. Your helper will differ, but the idea is the same: route each metric into the analytics pipeline you already have, and make sure it skips local and preview traffic unless you turn on a debug mode.

// Illustrative example: src/components/WebVitalsReporter.tsx
"use client";

import { useReportWebVitals } from "next/web-vitals";
import { track } from "@/lib/analytics";

export function WebVitalsReporter() {
  useReportWebVitals((metric) => {
    track("web_vital", {
      metric_name: metric.name,
      metric_value: metric.name === "CLS" ? Math.round(metric.value * 1000) : Math.round(metric.value),
      metric_rating: metric.rating,
      metric_id: metric.id,
      navigation_type: metric.navigationType,
    });
  });

  return null;
}

Mount it once in the root layout, next to the existing Analytics component:

// Illustrative example: src/app/layout.tsx (excerpt)
import { Analytics } from "@/components/Analytics";
import { WebVitalsReporter } from "@/components/WebVitalsReporter";

// inside the layout body
<Analytics />
<WebVitalsReporter />

A few notes on this setup:

  • The CLS value is a small decimal, so the example scales it by 1000 to keep the GA4 parameter readable. Choose a convention and document it, because a unitless CLS of 0.12 and a millisecond LCP should not share the same scale without a label.
  • The hook callback should stay stable. Define it at module level or wrap it with useCallback if you pass in props, so you do not get duplicate reports.
  • navigationType helps separate first loads from back-forward cache restores and reloads.
  • Test locally with whatever debug switch your analytics module provides, because many setups skip tracking on localhost and preview hosts by default.

Using the web-vitals library directly

If you want the attribution data for INP, or you need to send metrics somewhere other than your analytics pipeline, use the web-vitals package directly. The example below is illustrative, and it uses navigator.sendBeacon, which is designed to survive page unload.

// Illustrative example: src/lib/vitals.ts
import { onCLS, onINP, onLCP, type Metric } from "web-vitals/attribution";

const ENDPOINT = "/api/vitals";

function send(metric: Metric) {
  const body = JSON.stringify({
    name: metric.name,
    value: metric.value,
    rating: metric.rating,
    id: metric.id,
    path: window.location.pathname,
    attribution: metric.attribution,
  });

  if (navigator.sendBeacon) {
    navigator.sendBeacon(ENDPOINT, body);
  } else {
    fetch(ENDPOINT, { body, method: "POST", keepalive: true });
  }
}

export function reportWebVitals() {
  onCLS(send);
  onINP(send);
  onLCP(send);
}

Two cautions. First, web-vitals reports INP when the page is hidden or left, not on every click, by default. The library also has a reportAllChanges option for reporting intermediate values while you debug. Check its behavior in the web-vitals API reference for the version you install before you rely on it. Second, attribution can carry element selectors and timing details. Think about what you send and whether it contains any user content.

A minimal collection endpoint

The sendBeacon example posts to /api/vitals. A small Route Handler can accept it and hand storage to a background step. Keep it cheap, validate input, and never trust the payload:

// app/api/vitals/route.ts
import { after } from "next/server";

const NAMES = new Set(["LCP", "INP", "CLS", "FCP", "TTFB"]);

export async function POST(request: Request) {
  let body: unknown;
  try {
    body = await request.json();
  } catch {
    return new Response(null, { status: 400 });
  }

  const m = body as { name?: string; value?: number; rating?: string; path?: string; id?: string };
  if (!m.name || !NAMES.has(m.name) || typeof m.value !== "number" || !Number.isFinite(m.value)) {
    return new Response(null, { status: 400 });
  }

  after(async () => {
    // store: name, value, rating, path (strip query strings), device class
    console.log("vital", m.name, Math.round(m.value), m.path);
  });
  return new Response(null, { status: 204 });
}

Add rate limiting and sampling for busy sites. See Next.js Route Handlers for validation and rate-limit patterns, and server-side tagging if you route vitals through a tagging server.

Troubleshooting

ProblemLikely causeWhat to do
Search Console shows no dataNot enough traffic for CrUX, or URL groupingUse your own reporter; check an origin-level view
PageSpeed Insights has field data for the origin but not the URLLow traffic pageUse origin data as a hint, optimize shared templates
Lighthouse INP missingStandard load test has no interactionsUse a timespan recording or user-flow script
LCP element is a different thing than expectedLate-loading element becomes the largestCheck the LCP entry in DevTools; fix that element
CLS only on some visitsAds, A/B tests, cookie banners, personalizationReserve space for every late-loading slot, test with consent states
Metrics double-reportedNew callback function each renderKeep the useReportWebVitals callback reference stable
Metrics skewed by bfcache or prerenderRestores and prerenders count differentlySegment by navigationType
Improvements not visible after deployRolling field data windowWait, and confirm with your own reporter first

When not to chase scores

  • The page already passes at the 75th percentile in field data. Spend time on content and conversion instead.
  • Your traffic is tiny and field data is noise. Use lab checks for regressions, and avoid over-interpreting.
  • A fix would harm accessibility or usability (for example removing content to win a score).
  • You are optimizing a page that does not matter for search or for users.
  • A third-party widget is business-critical. Contain it (lazy load, reserve space, delay) rather than remove it.

A step-by-step checklist

Run through this list on your highest-traffic templates, not every page at once.

  1. Check field data first. Open Search Console's Core Web Vitals report and look for the URL groups marked poor or needs improvement. Note which metric fails.
  2. Confirm with your own data. If you have the reporter in place, group values by route and device. Check whether the failing route matches the Search Console group.
  3. Identify the LCP element. In DevTools, use the Performance panel or the Largest Contentful Paint entry to see which element is the LCP. Check whether it is an image, text, or a background.
  4. Fix LCP. Mark the above-the-fold image as high priority (fetchPriority="high" on Next.js 16, priority on 15 and earlier), size it with width and height or sizes, and make sure the font strategy is intentional.
  5. Fix CLS. Look for any element whose size changes after load. Reserve space for images, embeds, banners, and lazy components.
  6. Find the slow INP interaction. Use attribution data to group the worst interactions by element. Reproduce the most common one in the Performance panel.
  7. Reduce client JavaScript. Move non-interactive parts back to Server Components, lazy load heavy widgets, and trim large props.
  8. Break up long tasks. Split work that runs longer than 50 ms, and defer non-urgent work out of input handlers.
  9. Audit third-party scripts. Load each one with the right strategy, and remove any tag that no longer earns its cost.
  10. Deploy one change at a time and wait for field data. Keep a short log of what changed and when, so you can match improvements to releases.

Where this usually goes wrong

Optimizing from one Lighthouse score. A 98 in a lab run tells you little about the 75th percentile of real mobile users. Lab scores are useful for regression tests, not for deciding whether the site passes.

Marking everything as high priority. Setting priority, preload or fetchPriority="high" on every image makes the browser fetch them all early and slows the real LCP element. Reserve it for the one or two images that appear first.

Assuming LCP is the image. On many pages the LCP is a heading or a paragraph of text that is waiting on a font or a slow data fetch. Check the actual element before you optimize.

Forgetting that CLS includes late content. Shifts caused by a banner that loads two seconds in still count. Reserving space is the fix, not hoping the banner is fast.

Adding "use client" to whole pages. Marking a top-level layout or page as a Client Component ships its whole tree as JavaScript. Keep the client boundary as small as the interaction allows.

Questions that come up

Do Core Web Vitals affect rankings? Google says its ranking systems use Core Web Vitals as part of page experience, but it also says there is no single page experience signal and that good scores do not guarantee top results. Relevance and content quality remain the main factors.

Should I trust Lighthouse or Search Console? Use Search Console and other field data to decide whether a problem exists, because that is what real users and the ranking view see. Use Lighthouse to investigate and to catch regressions in a repeatable setting.

How long until a fix appears in Search Console? Field data uses a rolling window, so expect weeks rather than days for a site-wide change to be reflected.

Sources