Diagnose LCP with the Chrome DevTools Performance Panel
The settings that make a trace look like a phone, and how to see which of the four LCP parts your real visitors wait for longest.
- Good ≤ 2.5 s
- Needs improvement ≤ 4 s
- Poor > 4 s
Diagnosing LCP in DevTools in short
In the Chrome DevTools Performance panel, set Slow 4G and a 4x slower CPU and click Record and reload. The LCP breakdown insight splits Largest Contentful Paint (LCP) into time to first byte, resource load delay, resource load duration and element render delay, with your visitors' p75 per part once CrUX field data is set up. Fix the part they wait for longest.
Why check field data before you open DevTools?
The Performance panel is a lab tool: it measures one page load, on one device, on one network, yours. Google ranks on the 75th percentile of 28 days of real visits, so field data tells you which pages and which LCP element are slow, and a trace then shows why. This is the pattern I see on almost every audit: the developer's machine passes and the CrUX p75 fails. You measured a fast laptop on fiber; your visitors are on a mid-range Android on a train.
The top section of PageSpeed Insights gives the 28-day p75 for the URL and the origin, Search Console groups the slow URLs on mobile, and a real-user monitoring (RUM) tool such as CoreDash names the LCP element and the four parts of LCP per page. Fix and identify LCP issues goes through those steps. What people guess first is often unused JavaScript; the trace then shows a slow server and a lazy-loaded hero image.
How do you find the LCP element in DevTools?
The Performance panel names the LCP element in its Live metrics view, before you record anything, so it works as an LCP checker without an extension. Open DevTools (Ctrl+Shift+I, or Cmd+Option+I on a Mac) and the Performance tab: the LCP card shows the LCP of the page as you load it, with an LCP element link under the value. Hover the link and the element lights up on the page; click it and the Elements panel opens on it. The same card shows that load's four parts in a table when you hover it.
Under Field metrics, the Set up button adds your visitors' data from CrUX: the Field 75th percentile next to the Local value, for the URL or the whole origin, on phones or desktop. DevTools then sends the URLs you visit to Google while it is open. When the local LCP is more than a second off the field LCP, a list under the card, "Consider your local test conditions", gives the usual reasons: slower networks, a screen size that makes another element the largest, and content that changes between loads. After a recording, click the LCP marker in the timeline: its details name the element of that load.


Live metrics on corewebvitals.io: local and field LCP, the LCP element, and the network preset that matches the visitors.
A quick tip: the Core Web Vitals Visualizer, a free Chrome extension from corewebvitals.io, highlights the LCP element on any page without opening DevTools.
Which throttling should you use for an LCP trace?
Slow 4G with a 4x slower CPU is the setting for a phone, close to what Lighthouse simulates for mobile. Set both in the Environment settings of Live metrics, or in Capture settings, the gear icon of the recording toolbar.
- CPU: 4× slowdown stands for a mid-range phone and 6× for a cheap one; 20× is slower than a low-end phone. Calibrate measures your computer and adds Mid-tier mobile and Low-tier mobile presets with the factor for that computer, because 4x on a fast desktop and 4x on an old laptop are two different phones. Use the low-tier preset when your slow LCPs come from cheap phones.
- Network: Slow 4G is the preset Chrome used to call Fast 3G; Fast 4G and 3G are the faster and the slower one. With field data set up, DevTools names the preset closest to your visitors' 75th percentile round trip time and marks it as recommended. Chrome DevTools Network panel settings covers the Network panel itself.
The throttling decides which part looks largest in the trace. On a test page built like an estate agent's WordPress site, with Elementor's entrance animation on the photo, a load without throttling had an LCP of 1.48 seconds, 1.33 seconds of it element render delay, and a download of 0.03 seconds. With Slow 4G and a 4x slower CPU, the same page had an LCP of 4.64 seconds, 4.04 seconds of it the download. On the same code, the unthrottled trace points at the animation and the throttled one at the image file. The Field p75 table of LCP breakdown shows which of the two your visitors get.

No throttling, one load

Slow 4G, 4x CPU, one load
LCP breakdown of the test property page in Chrome 158. Each screenshot is a single load; the figures in the text are medians of several loads.
How do you record a page load for LCP?
Record and reload captures the trace from the first request: DevTools opens a blank page, starts recording, loads your page and stops by itself five seconds after the load event.
- Open the page in an incognito window. Extensions add scripts that show up in the trace as long tasks.
- Tick Disable network cache to record a first visit; leave it off to record a returning visitor.
- Set Slow 4G and a 4x slower CPU, or the calibrated Mid-tier mobile preset.
- Click Record and reload (Ctrl+Shift+E, or Cmd+Shift+E on a Mac) and keep your hands off the page: a scroll or a click ends LCP early.
The same settings work for a trace for any Lighthouse notice.
How do you read the LCP breakdown insight?
LCP breakdown, called LCP by phase in older Chrome versions, sits in the Insights sidebar on the left after a recording and splits the LCP of the recorded load into four parts. With field data set up, a second table under it, with a Field p75 column, gives each part at the 75th percentile of your real Chrome visitors when CrUX has image LCP data for the URL or the origin. Each part is its own percentile, so the four don't add up to the field LCP.
The four parts, each linked to the page that fixes it:
- Time to first byte: the wait for the first byte of the HTML. In the trace: the first bar in the Network track.
- Resource load delay: from that byte until the image request starts. In the trace: the gap before the image's bar.
- Resource load duration: the image download. In the trace: the length of the image's bar.
- Element render delay: from the end of the download until the paint. In the trace: the Main and Animations tracks up to the LCP marker.
A text LCP has two rows, time to first byte and element render delay: there is no file to download, and the wait for a web font counts as render delay. Opening the insight zooms the timeline to the LCP and draws the parts as bands along its bottom; hover a row and its part lights up.
Read the Field p75 table before the lab table. When the largest part in the lab is not the largest in the field, fix the part the field names, and change the throttling before you trust the lab rows. In the web.dev trace below, the lab's largest part is element render delay (611 ms) and the field's is time to first byte (1,342 ms); the download took 2 ms against 497 ms.

LCP breakdown for web.dev: the lab table, and the Field p75 table under it.
According to the State of Web Vitals, time to first byte is the largest part of LCP on phones on 67.6% of the sites with an image LCP and all four parts in CrUX, so when your page has no Field p75 table, start with time to first byte. In PageSpeed Insights the four rows come from a fast, unthrottled load while its LCP is calculated for a slow phone, so they don't add up to its LCP; in a DevTools recording they add up.
What does LCP request discovery check?
LCP request discovery shows whether the browser finds the LCP image early enough, with three checks on its request: "fetchpriority=high should be applied", "Request is discoverable in initial document" and "LCP resources shouldn’t use loading=lazy". Each red check is a reason the image loads later than it could. On the timeline the insight marks the wait before the image's request as "LCP image loaded ... after earliest start point", counted from the HTML's first byte: that wait is the resource load delay.
For a text LCP the insight says "No LCP resource detected because the LCP isn’t an image". LCP request discovery in Lighthouse goes through each check and its fix.


A hotel test page with the photo as a background in a stylesheet: two red checks, and the photo's request starts after the stylesheets.
Where is each part of LCP in the trace?
Each part of LCP has its own place in the trace: the HTML request for time to first byte, the start of the image's request for load delay, the length of its bar for the download, and the main thread and animations between the end of that bar and the LCP marker for render delay. The Network track shows every request, with a warning triangle on the render-blocking ones; in the Main track, a task over 50 ms gets a triangle and red stripes.
Time to first byte: the HTML request
The first bar in the Network track is the HTML. Click it and its details show the timing: a long wait for the first byte is the server building the page, or a redirect before it. Most often the page is built on every request: put a page cache in front of it, at the CDN first, then at the host, then a plugin. DevTools throttling adds its own latency to this request, so the Field p75 row says how slow your server is for visitors. Time to first byte goes through its parts.
Resource load delay: when the image request starts
The image request should start right after the HTML arrives. When its bar starts after the stylesheets or after a script, the browser found the image late. Click the request: its initiator is the file that asked for the image, the HTML or a stylesheet or script. The usual causes are a background image in CSS, a slider or lazy-load script that sets the image, and loading="lazy" on it. Without code, show the photo as a normal image in the page and exclude it from lazy loading in your optimisation plugin; in the HTML that is an <img> with fetchpriority="high". Resource load delay has the fix per platform.
Resource load duration: the image download
The length of the image's bar is the download. On a throttled trace any heavy file has a long bar, and the downloads running next to it share the throttled bandwidth. Compressing the LCP image is the fix people try first, and on most sites it shortens the smallest part, so check the Field p75 row before you spend time on it. Resource load duration covers the file size, the other downloads and the image server.
Element render delay: the gap after the download
When the image's bar ends well before the LCP marker, the page held the image back. Look at what runs in that gap: a long task in the Main track, a fade in the Animations track that ends at the LCP marker, or for a text LCP the web font arriving. Click a long task to see its script: far more often a tag manager or a consent script than the site's own code; Dim 3rd parties in the toolbar greys out the work that isn't yours.
The Delay JavaScript settings of WP Rocket, Perfmatters and LiteSpeed Cache clear Lighthouse notices, and when the script that shows your photo is one of the delayed ones, the photo waits for the visitor's first tap until you add that script to the plugin's exclusions. LCP breakdown in Lighthouse has the settings per page builder, and Element render delay goes through each cause.
Did the change shorten LCP, or did the wait move?
Record again with the same throttling and the same cache setting, and compare all four parts as well as LCP itself. When one part shrinks and another grows by about the same, the image still waits, now for something else.
Most people start by converting images to WebP and deferring JavaScript. Both are good ideas, and on a slow LCP they hardly ever fix it on their own. On a test property page with an entrance animation on the photo, WebP at phone size took 2.5 seconds off the download, and 1.9 seconds of that moved into element render delay, because the animation now held the photo back. LCP breakdown in Lighthouse has each step of that test.
For real visitors, CoreDash shows the four parts per page from the next visits; Search Console takes up to 28 days. An AI agent with the Chrome DevTools MCP can record and read the same trace: Fix LCP with an AI agent shows how.
When your trace never matches the Field p75, or the render delay comes from a script you can't find or can't change, book a Core Web Vitals power hour: we record your slowest template together and find the part your visitors wait for.

Need a faster site?
I'm Arjen, and I've been fixing slow sites for 17 years. If you're running into issues you can't fix yourself, send me your URL and let's have a chat.
Send me your URL
Why isn't our fix working?
Sometimes the CDN still serves the old HTML, or the fix went into the desktop template and mobile uses another one. Send me your URL and the problem, and I reply with a few times. I check your field data first, then we spend one hour on your site, and within a day you have my notes in writing. €350 excl. VAT.
Send me your URLNo developer to build the fix? I do the work myself, on a copy of your site.