The largest content paint (LCP) in the Core Web Vitals measures how quickly a site is loaded from a visitor perspective. It looks at how long after opening a page the largest content element is visible. If your site is loaded slowly, it is bad for user experience and can also get your site to rank lower in Google.
When trying to solve LCP problems, it is not always clear what to focus on. Is the server too slow? Are pictures too big? The content is not displayed? Google has been working on tackling it recently by introducing the LCP undivids that tell you where delays on the page come from. They have also added this data to the Chrome UX report so you can see what causes delays for real visitors to your site!
Let’s look at what the LCP bottoms are, what they mean for your site speed and how to measure them.
The four LCP subdivrals
The LCP subdivisions divided the largest content paint metrics into four different components:
- Time for First Byte (TTFB): How quickly does the server respond to the document request.
- Resource load delay: Time spent before the LCP image starts downloading.
- Resource load time: Time spent downloading the LCP image.
- Item reproduces delay: Time before the LCP element appears.
Resource dimensions apply only if the largest side element is an image or background image. For text elements, the load delay and load time components are always zero.
How to measure the LCP bottoms
One way to measure how much each component contributes to LCP scores on your site is to use Debugbear’s web site speed testing. Expand the largest content paint metration to see the bottom and other details related to your LCP score.
Here we can see that TTFB and image load duration together account for 78% of the total LCP score. It tells us that these two components are the most effective places to start optimizing.
What happens in each of these stages? A network request waterfall can help us understand what resources are loaded through each step.
The LCP image discovery display filters the visualization of the waterfall to only the resources that are relevant to showing the largest content paint image. In this case, each of the first three phases contains a request and the final phase ends quickly without being loaded new resources. But it depends on your specific site and will not always be the case.
Time for first byte
The first step to show the largest side element is to download the document HTML. We recently published an article on how to improve the TTFB metric.
In this example, we can see that creating the Server connection does not take that long. Most of the time is spent waiting for the server to generate since HTML. So to improve TTFB, we need to speed up this process or cache HTML so we can skip the HTML generation completely.
Resource load delay
The “resource” we want to load is the LCP image. Ideally we just have one
But sometimes we get a load delay, as is the case here. Instead of loading the image directly, using the page lazysize.jsAt A picture Lazy Loading Library It only loads the LCP image when it has found that it appears in Viewport.
Part of the load delay is caused by having to download the JavaScript library. But the browser also has to finish the side layout and start reproducing content before the library will know that the image is in the view gate. After completing the request, there is a CPU assignment (in orange) leading up to the first contented paint milestone when the page begins to reproduce. Only then does the library trigger the LCP image request.
How do we optimize this? First of all, instead of using a lazy load library, you can use native loading="lazy" Picture attribute. In that way loading images No longer depends on the first loading of JavaScript code.
But more specifically, the LCP image should not be loaded lazy. That way, the browser can start loading it as soon as the HTML code is ready. According to Google, aim at eliminating the delay of resource load completely.
Resources Load Duration
Subpart with load duration is probably the most straightforward: you need to download the LCP image before you can show it!
In this example, the image is loaded from the same domain as HTML. It’s good because the browser doesn’t have to connect to a new server.
Other techniques you can use to reduce the load delay:
Item reproduces delay
The fourth and last LCP component, reproduction of delay, is often the most confusing. The resource has loaded, but for some reason the browser is not ready to show it to the user yet!
Fortunately, in the example we have looked at so far, the LCP image appears quickly after it is loaded. A common cause of reproduction is that The LCP element is not a picture. In this case, the reproduction delay is caused by Render-blocking scripts and Styles sheets. The text can only appear after these are loaded and the browser has completed the reproduction process.
Another reason why you may see the Render Delay is when the site pre -charges the LCP image. Breeding is a good idea as it practically eliminates any load delay and ensures that the image is loaded early.
But if the image ends to download before the page is ready to reproduce, you will see an increase in reproduction delay on the page. And that’s fine! You’ve improved your site speed in general, but after optimizing your image, you’ve revealed a new bottleneck to focus on.
LCP -Bottom in Real User Crux -Data
Looking at the largest content painting base in lab-based tests can provide a lot of insight into where to optimize. But all too often the LCP in the laboratory does not match what happens to real users!
That’s why in February 2025, Google started to include subpartar data in the Crux data report. It’s not (yet?) Included in PageSpeed ​​Insights, but you can see these metrics in Debugbear’s tab “Web Vitals”.
A super useful bit of info here is LCP resource type: It tells you how many visitors saw the LCP element as a text element or picture.
Even for the same page, different visitors will look slightly different content. For example, different elements are visible based on the unit size, or some visitors will see a cookie banner while others see the actual side content.
To make the data easier to interpret, Google only reports sub -sections for images.
If the LCP element is usually text on the page, the lower parts will not be very useful as it does not apply to most of your visitors.
But breaking down text LCP is relatively easy: all that is not part of TTFB scores is reproduced.
Track the bottoms on your site with real user monitoring
Labdata does not always match what real users are experiencing. Crux -Data is superficial, only reported to pages with high trafficand takes at least 4 weeks To fully update after a change is rolled out.
Therefore, a Real-user’s surveillance tool like Debugbear is good with when you resolve your LCP scores. You can Track score across all sides On your site over time and get dedicated dashboards to each LCP sub -section.
You can too Review specific visitorsSee what the LCP image was for them, inspect a request water and check LCP sub -sections. Sign up for a free sample.
Conclusion
Having multiple granular metric data available for the largest content paint gives web developers a big leg up when they make their website faster.
Inclusion of bottom in Crux provides new insights into how real visitors are experiencing your site and can tell if the optimizations you are considering would really be attractive.
(GG, YK)