Skip to content
Tutorials Center
My learning

Topics

Lesson 21 of 36 ยท Performance Panel

Core Web Vitals in DevTools

Measure Largest Contentful Paint, Cumulative Layout Shift and Interaction to Next Paint in DevTools, learn the thresholds, and trace each metric to its cause.

Google summarizes real-world page experience in three numbers called the Core Web Vitals: how fast the main content appears (LCP), how stable the layout is (CLS) and how quickly the page reacts to input (INP). They influence search ranking and, more importantly, they match what users feel. DevTools can show all three for your own session and, in a recording, explain exactly which element or event caused a bad value.

This lesson covers where to find each metric in DevTools, what the thresholds are, and how to go from a bad number to a specific cause.

The three metrics

Metric Measures Good Needs improvement Poor
LCP Largest Contentful Paint When the biggest visible image or text block finished rendering up to 2.5 s 2.5 to 4 s over 4 s
CLS Cumulative Layout Shift How much visible content moved unexpectedly up to 0.1 0.1 to 0.25 over 0.25
INP Interaction to Next Paint How long the page took to paint after the slowest typical interaction up to 200 ms 200 to 500 ms over 500 ms

Google evaluates these at the 75th percentile of real visits, split by mobile and desktop. That means a page passes only if three out of four visits are good, so one lucky run on your fast laptop proves nothing.

Where to see them in DevTools

Live metrics screen. Open the Performance panel and, before recording, look at the live view. It reports LCP, CLS and INP for the current page as you use it, and it can show an LCP element you can hover to highlight on the page. Because it measures a real session, you can click around and watch INP change.

Field data. The same screen can compare your numbers with real-user data from the Chrome UX Report (CrUX) if you enable it. Field data comes from real users and is what Google uses for ranking; your local number is lab data. When they disagree, believe the field data and use the lab data to find the cause.

In a recording. The Timings track marks FCP and LCP with flags. Click the LCP marker and the summary names the element (for example an <img>) and its URL, and recent versions add an LCP breakdown insight showing four parts: time to first byte, resource load delay, resource load duration and element render delay. The Layout Shifts track shows purple diamonds; click one to see the shift's score and which elements moved. The Interactions track shows each input with its duration split into input delay, processing time and presentation delay.

Diagnosing each metric

LCP: find which of four phases is slow

LCP time is the sum of the four phases above. A large time to first byte means a slow server or redirect. A big load delay means the browser discovered the image late (it was in CSS or injected by JavaScript instead of the HTML). A big load duration means the file is too large. A big render delay means something blocked rendering after the image arrived, such as a long task or render-blocking CSS.

JS Stand-in: LCP phase breakdown

Press Run (or Ctrl + Enter) to see the console output here.

No output.

In the first call the biggest cost is load delay: the fix is not a smaller image but telling the browser earlier, for example by putting the image in the HTML with fetchpriority="high" or a preload hint.

CLS: find what moved

Open the Layout Shifts track and click each shift. The usual culprits are images and iframes without width and height (or aspect-ratio), ads that load late, web fonts that swap with different metrics, and content injected above existing content. A shift's score is impact fraction x distance fraction: how much of the viewport was affected multiplied by how far things moved relative to the viewport.

JS Stand-in: score a layout shift

Press Run (or Ctrl + Enter) to see the console output here.

No output.

One late banner on a phone consumed more than half of the whole 0.1 budget in this example. Reserving space for it removes the shift entirely.

INP: find the slow phase

Click an interaction in the Interactions track. If input delay is large, the main thread was busy with something else when the user clicked, so look for long tasks just before. If processing time is large, your event handler is slow. If presentation delay is large, the handler finished but rendering (style, layout, paint) took long, often because the DOM is huge or the handler changed many things.

A workflow that works

  1. Open the live metrics view and use the page normally on a throttled profile.
  2. Note which metric is not green.
  3. Record a trace that reproduces it (reload for LCP and CLS, interaction for INP).
  4. Click the marker, read the phase breakdown, fix the biggest phase, record again.

Check your understanding

Quick check ยท 4 questions

of 4 answered You scored / 4 ยท perfect!

  1. 1. What is the 'good' threshold for LCP?

    LCP is good at 2.5 s or less. 0.1 is the CLS threshold and 200 ms is the INP threshold.
  2. 2. A large 'resource load delay' in the LCP breakdown suggests that:

    Load delay is the gap between first byte and the start of loading the resource: the resource was found late, for example because it was added by JavaScript.
  3. 3. Which is a common cause of layout shifts?

    Content without reserved space pushes other content when it loads.
  4. 4. Google's Core Web Vitals pass/fail is based on which statistic of real visits?

    Pages are assessed at the 75th percentile of field data, so most visits must be good.

Summary

  • Core Web Vitals: LCP (loading), CLS (stability), INP (responsiveness), judged at the 75th percentile.
  • DevTools shows live metrics, field data comparison, and per-recording breakdowns.
  • LCP splits into TTFB, load delay, load duration and render delay; fix the biggest.
  • CLS comes from content moving without reserved space; INP splits into input delay, processing and presentation.
  • Lab data finds causes; field data tells you whether real users are affected.

Next: Long Tasks and Main Thread Work