Largest Contentful Paint (LCP): Causes and Fixes
- Filed November 10, 2026
- Page speed and Core Web Vitals, guide 6 of 10
Largest Contentful Paint measures how long it takes for the largest image or text block in the viewport to render. Google’s guidance is that “LCP should occur within 2.5 seconds of when the page first starts loading”, measured at the 75th percentile of page loads, separately for mobile and desktop (web.dev on Web Vitals). A slow LCP is not one problem. It is the sum of four delays, and fixing it starts with finding which of the four is large on your page.
The four parts of LCP
web.dev’s LCP optimization guide breaks the metric into subparts (optimizing LCP):
| Subpart | What it covers | Guideline share of LCP |
|---|---|---|
| Time to First Byte (TTFB) | From navigation start to the first byte of the HTML | About 40% |
| Resource load delay | From TTFB until the browser starts loading the LCP resource | Under 10% |
| Resource load duration | Time to download the LCP resource (an image, for example) | About 40% |
| Element render delay | From the end of the resource load until the element renders | Under 10% |
web.dev notes these breakdowns are guidelines, not rules. Their value is diagnostic: a page whose resource load delay is half the LCP has a discovery problem, not an image size problem.
If the LCP element is text, there is no resource to load, and LCP is TTFB plus render delay.
A diagnostic sequence
1. Start with field data
Lab tools measure one load on one device; real users vary. web.dev’s comparison of lab and field data notes that lab tests run on a single device, network and location, typically with a cold cache, and that the LCP element can differ between devices because different elements are visible on different screen sizes (lab and field data differences).
- Search Console’s Core Web Vitals report groups similar URLs and reports their status from Chrome UX Report (CrUX) data.
- PageSpeed Insights shows CrUX field data for the URL (or the origin if the URL lacks data) above its lab results.
Confirm that LCP is poor in the field, and for which template and device, before optimizing.
2. Identify the LCP element
In Chrome DevTools’ Performance panel or in Lighthouse, find which element is the LCP candidate. On mobile it might be a hero image; on desktop a heading. Field tools that use the web-vitals library’s attribution build can report the element from real users.
3. Measure the subparts
DevTools’ performance insights show the LCP breakdown for a recorded load. Note which subpart dominates.
4. Fix the dominant subpart
Apply the fixes below to the subpart that dominates on that template. Shortening a subpart that is already small barely moves the total.
Fixes by subpart
Long TTFB
- Server response time, redirects and connection setup all count. Reduce backend processing, cache HTML where possible, use a CDN for distant users, and remove redirect hops on landing pages.
Long resource load delay (late discovery)
- web.dev’s guidance is that the LCP resource “should be discoverable from the HTML source”. An image set as a CSS background, injected by JavaScript or lazy-loaded is found late.
- Put the LCP image in an
<img>element in the HTML, or preload it. - Raise its priority: web.dev describes adding
fetchpriority="high"to the LCP image element as a way to make LCP happen sooner (fetch priority). - Do not lazy-load it. web.dev’s lazy-loading guidance says to use
loading="lazy"only for images outside the initial viewport and to use the browser’s default eager loading especially for LCP images (browser-level lazy loading).
Long resource load duration
- Serve the image at the size it is displayed, with responsive
srcset. - Use efficient formats (AVIF, WebP) and appropriate compression.
- Serve from a CDN close to users.
Long element render delay
- Render-blocking CSS and JavaScript in the head delay rendering even after the image arrives.
- Elements hidden until a script runs (A/B testing scripts, carousels, client-side rendering) wait for that script.
- web.dev gives an example of why the order matters: switching a hidden LCP image to a better format reduces load duration but “wouldn’t actually improve LCP because the time would just shift to the element render delay subpart”.
Configuration example
Before (illustrative):
<div class="hero" style="background-image: url('/img/hero-2400.jpg')"></div>
<script src="/js/carousel.js"></script>
After:
<img src="/img/hero-1200.avif"
srcset="/img/hero-800.avif 800w, /img/hero-1200.avif 1200w, /img/hero-1800.avif 1800w"
sizes="100vw"
width="1200" height="600"
fetchpriority="high"
alt="Interior of the store's flagship showroom">
<script src="/js/carousel.js" defer></script>
What changed: the image is discoverable in HTML, sized responsively, in a modern format, prioritized, and the script no longer blocks parsing. Width and height also reserve space, which helps layout stability. The example serves AVIF only; if some of your visitors use browsers without AVIF support, wrap the image in a <picture> element with a WebP or JPEG fallback and keep fetchpriority="high" on the <img> inside it.
- Expected result: shorter resource load delay and render delay.
- Verification: compare LCP subparts in DevTools before and after on throttled mobile; watch the field data update over the following 28 days, since CrUX data covers a trailing 28-day period.
- Lab versus field: lab gains do not guarantee field gains if real users hit different elements or slower networks.
LCP and rankings
Core Web Vitals are used by Google’s ranking systems, according to Google’s page experience documentation, which also says that good results in Core Web Vitals reports “doesn’t guarantee that your pages will rank at the top” and that chasing a perfect score just for SEO “may not be the best use of your time” (Google on page experience). Fix LCP for the people waiting for the page to show its main content; treat ranking effects as secondary and uncertain.
LCP checklist
- [ ] LCP is poor in field data for a specific template and device.
- [ ] LCP element identified on that template.
- [ ] Subparts measured; dominant subpart named.
- [ ] LCP resource in HTML, not lazy-loaded, prioritized.
- [ ] Image sized and compressed appropriately.
- [ ] No render-blocking script or hidden-until-script element delaying it.
- [ ] TTFB acceptable for the audience’s locations.
- [ ] Field data rechecked after 28 days.