Part of the Core Web Vitals series. For the full picture, start with Core Web Vitals: what they are, how they affect SEO and how to improve them.
Largest Contentful Paint is the Core Web Vital most sites fail first, and the one with the most predictable causes. It’s also the easiest to misdiagnose: “make the images smaller” is the usual advice, while the real delay is often the browser discovering the image late or waiting on the server.
This guide explains what LCP measures, how to break a slow LCP into parts, and which fixes address which part.
What is Largest Contentful Paint?
LCP is the time from when the user starts loading the page until the largest image or text block in the viewport renders. web.dev defines it as “the render time of the largest image, text block, or video visible in the viewport, relative to when the user first navigated to the page” (LCP).
Elements that can be the LCP element:
<img>elements, and<image>elements inside<svg><video>elements (their poster image or first frame)- Elements with a background image loaded through
url() - Block-level elements containing text
On most pages it’s the hero image, a product photo or the first paragraph of an article.
What is a good LCP?
| Rating | LCP at the 75th percentile |
|---|---|
| Good | 2.5 seconds or less |
| Needs improvement | Over 2.5 and up to 4 seconds |
| Poor | Over 4 seconds |
The 75th percentile is measured “segmented across mobile and desktop devices”, so a page can pass on desktop and fail on mobile. It’s a Core Web Vital, which Google says is used by its ranking systems; see the Core Web Vitals guide for how much that matters.
What makes LCP slow?
Every LCP can be split into four consecutive parts. web.dev’s LCP optimisation guide defines them and suggests how the time should be spread:
| Part | What it is | Ideal share |
|---|---|---|
| Time to first byte | “From when the user initiates loading the page until the browser receives the first byte of the HTML document response” | ~40% |
| Resource load delay | “The time between TTFB and when the browser starts loading the LCP resource” | < 10% |
| Resource load duration | “The duration of time it takes to load the LCP resource itself” | ~40% |
| Element render delay | “The time between when the LCP resource finishes loading and the LCP element rendering fully” | < 10% |
The principle behind the split: “The vast majority of the LCP time should be spent loading the HTML document and LCP source.” If load delay or render delay is large, the browser is waiting for no good reason, and that’s usually the cheapest time to win back.
How do you fix a slow LCP?
web.dev recommends working through the parts in this order.
1. Eliminate resource load delay
The LCP image should start loading as soon as the HTML arrives.
- Make it discoverable in the HTML. An image referenced only in a CSS file or injected by JavaScript is found late. Use an
<img>in the initial HTML, or preload it. - Don’t lazy-load it.
loading="lazy"on the hero image tells the browser to wait. Lazy-load below-the-fold images only. - Raise its priority with
fetchpriority="high"on the LCP image.
2. Eliminate element render delay
The image has arrived but isn’t shown yet.
- Reduce render-blocking CSS and JavaScript in the
<head>: inline critical CSS, defer non-critical scripts. - Render on the server where you can; content built by client-side JavaScript can’t render until the scripts run. See JavaScript SEO.
- Keep the main thread free during load so painting isn’t blocked by long tasks.
3. Reduce resource load duration
- Serve the right size for the viewport with
srcsetandsizes, not a 3000-pixel original. - Use modern formats and sensible compression.
- Serve from a CDN close to users, with long cache lifetimes for static assets.
4. Reduce time to first byte
Everything starts with the HTML. Caching, a CDN, a fast backend and no unnecessary redirects all cut TTFB. See how to reduce TTFB.
How do you find slow LCP pages across a site?
PageSpeed Insights shows a URL’s field LCP, its lab LCP and the LCP element. To see it across a site in Crawlens:
- Run Measure Core Web Vitals for your most important pages, or Real-user data for all pages to pull CrUX data for every indexable page.
- The audit flags Poor LCP for real users (over 4 s at the 75th percentile) and Core Web Vitals need improvement, with the measured value, the device and whether it’s the URL’s own data or the whole site’s.
- Open a flagged URL’s Page speed tab for its lab LCP, Lighthouse score and the Biggest opportunities, such as oversized images or render-blocking resources, with their estimated savings.
- Check Slow server response (over 1 second) for the same pages: a slow first byte from the crawl is a strong hint that TTFB is a large part of the LCP.
Group flagged URLs by template. If every product page fails, the fix is in the product template.
How do you confirm the fix?
Re-test a few pages in the lab to confirm the change is live: lab LCP and the opportunity list should change immediately. Field LCP follows over the next 28 days as CrUX’s window rolls forward. In Crawlens, measure again and use Compare to see which pages left the poor range.
Checklist
- LCP element identified for each main template
- LCP image in the initial HTML (or preloaded), not lazy-loaded
-
fetchpriority="high"on the LCP image - No render-blocking CSS or JavaScript delaying the first render
- Main content rendered on the server where possible
- LCP image sized for the viewport, in a modern format, from a CDN
- TTFB low: caching, CDN, no redirect chains
- Field LCP within 2.5 s at the 75th percentile on mobile and desktop
Frequently asked questions
What is a good LCP score?
2.5 seconds or less, measured at the 75th percentile of page loads, separately for mobile and desktop. Between 2.5 and 4 seconds needs improvement, and over 4 seconds is poor.
What elements can be the LCP element?
Images, image elements inside SVG, videos, elements with a CSS background image, and block-level text elements. It's whichever of these is largest in the viewport when it renders.
Should I lazy-load the LCP image?
No. web.dev advises against lazy-loading critical images, because it delays when the browser starts loading them. Lazy-load images below the fold and load the LCP image eagerly, ideally with fetchpriority="high".
Why is my LCP good in Lighthouse but poor in field data?
Real users have slower devices and networks, arrive through redirects and land on different pages and states than a single lab test. Field data also includes things like connection setup that a warm lab test may not. Trust field data for the verdict and use the lab to find causes.
Does a CDN improve LCP?
Often, because it shortens the distance for both the HTML and the LCP image, which cuts time to first byte and resource load duration. It won't help if the delay comes from late discovery or render-blocking code.