Fix LCP on Image Heavy Pages, A Subpart Audit Guide

A practitioner's audit for LCP failures on image-heavy homepages and landing pages: find the slow subpart, then fix server response, discovery, priority, format and CDN in order.

Fix LCP on Image Heavy Pages, A Subpart Audit Guide

The usual first fix for a slow hero image is to compress it harder. That is often the wrong move. Google’s own research says the time spent downloading the image is rarely the main bottleneck for most sites. On image-heavy homepages and campaign landing pages, Largest Contentful Paint usually fails before the image has even started downloading.

This guide shows how to audit an LCP failure part by part. It then covers the server, discovery, format and CDN decisions that bring it under 2.5 seconds.

Get a subpart-level LCP audit of your homepage and landing pages, with fixes ranked by impact.

Audit my LCP

Where do the 2.5 seconds actually go?

LCP measures the time from when the user starts loading a page to when the largest image or text block in the viewport has rendered. Google’s target is that sites should reach an LCP of 2.5 seconds or less for at least 75% of page visits. That target describes real visitors on their own devices and networks, not a single test run. A fast test on office Wi-Fi proves nothing.

The useful step is breaking that single number into four parts that run one after another:

  • Time to First Byte (TTFB): the time until the first byte of the HTML arrives.
  • Resource load delay: the gap between TTFB and the moment the browser starts requesting the hero image.
  • Resource load duration: how long the image takes to download.
  • Element render delay: the gap between the image finishing and it appearing on screen.

On a well-optimized page, Google’s LCP optimization guide puts TTFB at roughly 40% of LCP and resource load duration at roughly 40%. The same guidance keeps each of the two “delay” subparts under 10%. Those proportions are the diagnosis. If resource load delay takes up a third of your LCP, a smaller image will not help.

Shrinking the hero image only helps if download time is the bottleneck. If the image is hidden until JavaScript runs, the time you save in download simply moves into render delay, and LCP stays where it was.

For a broader introduction to the metric, see our explainer on Core Web Vitals metrics. The rest of this article assumes you already know what LCP is and need to make it pass.

Start with field data, not a Lighthouse score

Lighthouse runs on one simulated device with one network profile, and it starts with an empty cache every time. Real visitors do not behave like that. Use the Chrome User Experience Report (CrUX) through PageSpeed Insights, or your own real user monitoring (RUM), to confirm the failure is real and to see which device types it affects.

PageSpeed Insights shows four views: mobile and desktop, each for the single URL and for the whole origin. Check which view you are looking at. A campaign landing page with little traffic often has no URL-level data, so the tool silently shows origin data. That figure may describe your blog, not your landing page.

Homepages deserve particular attention. Many homepage visitors are first-time visitors, so the page often loads “cold” with nothing cached. That tends to make it one of the slowest pages on the site, even if the build looks the same as every other template.

Once the failure is confirmed, open a trace in the Chrome DevTools Performance panel. It shows the four subpart timings next to your field data. That breakdown decides which of the sections below to work on first.

The server response: why campaign pages fail first

A high TTFB can make a 2.5-second LCP very hard to reach, and sometimes impossible. Google lists four common causes: multiple redirects, visitors far from the nearest server, poor network conditions, and query parameters that prevent cached content from being served.

Campaign landing pages often run into all four. A paid social click typically goes through a link shortener, then an ad platform redirect, then an HTTP-to-HTTPS hop, and sometimes a trailing-slash redirect. Each step is a full round trip before any HTML arrives.

The query parameter problem is less visible and usually costs more. Every ad click adds UTM parameters and a click ID (gclid, fbclid and similar). If your CDN includes the full query string in its cache key, every click is a unique URL. Every click is then a cache miss, and every request goes all the way back to your origin server. The page may be fully static and still get no benefit from the CDN cache.

The fix is a configuration decision, not new code. Configure the CDN to strip known tracking parameters from the cache key, or to ignore the query string entirely on landing page paths. Analytics still reads the parameters in the browser. Check that your platform does this. In Cloudflare, Fastly, Akamai and CloudFront it is a cache-key setting, not a default.

The rendering model also matters. Server-side rendering costs some server time, but it puts the hero image into the initial HTML, where the browser finds it straight away. Static generation (prerendering at build time) is usually better again for campaign pages that change weekly, not per visitor.

Discovery and priority beat compression

Resource load delay is where most image-heavy pages lose time. The rule is simple: the hero image should start downloading at the same time as the first resource the page requests. If it starts later, there is time to recover.

Browsers find resources early using a preload scanner. It reads the raw HTML before CSS and JavaScript have run. The scanner cannot see the hero image if any of these are true:

  • The hero is a CSS background image, which is common in page builders and carousel components.
  • The image is added to the page by JavaScript, as many client-rendered frameworks and slider libraries do.
  • A lazy-loading library hides the real address in a data-src or data-srcset attribute.

In each case the browser has to download and run another file before it even knows the image exists. The best fix is to use a standard img element with its src and srcset written into the server-rendered HTML. If the design really needs a CSS background, add a preload link in the document head with as=”image” and fetchpriority=”high”. The browser then fetches the image alongside the stylesheet.

Priority is the next lever. Browsers do not give images top priority by default, because images do not block rendering. Adding fetchpriority=”high” to the hero img element raises it. Two rules come with that:

  • Never use loading=”lazy” on the LCP image. CMS templates often apply it to every image, including the hero. It always delays the image.
  • Do not mark everything as high priority. Google notes that setting high priority on more than one or two images stops it from helping LCP. On carousels, mark the first slide high and the hidden slides low.

Next, check where the image is served from. A hero on a separate image domain needs a new DNS lookup, TCP connection and TLS handshake before any bytes arrive. Serving critical images from the same origin as the HTML reuses the existing connection. Many CDNs can route an /images/ path to the image service while keeping the main hostname.

Render delay: the A/B test hiding your hero

Sometimes the image has fully downloaded and still does not appear. Element render delay usually comes from render-blocking stylesheets or synchronous scripts in the document head. Another cause is long JavaScript tasks that block the main thread, which browsers also use to render images.

On marketing pages there is one common culprit: client-side A/B testing tools that hide the page until the variant is decided. The hero is ready, but the page stays hidden. If experiments matter, move variant assignment to the server or the CDN edge. Our guide to third-party script budgets covers how to negotiate this with the teams who own those tags.

Also check the size of your stylesheet. If the CSS takes longer to download than the hero image, the image waits for it. Remove unused rules and split out non-critical CSS. Inlining only makes sense when the critical CSS is genuinely small.

Image format and CDN configuration

Download time still matters on mobile connections and with oversized assets, so do this work. It just comes after the steps above. Google gives four ways to cut download time: make the file smaller, shorten the distance it travels, reduce competition for bandwidth, or avoid the network altogether.

For file size, serve AVIF with a WebP fallback, using a picture element or content negotiation on the Accept header. Then make the srcset widths match the sizes the layout actually displays. A hero image several times wider than the phone screen it appears on is mostly a sizing problem, not a format problem.

An image CDN handles both automatically: it resizes, chooses the format and caches at the edge. If you use content negotiation, set the Vary header correctly. Otherwise the CDN can store an AVIF response and serve it to a browser that cannot decode it. For the font and hero-image details that sit next to this work, see our guide to hero image and font fixes.

An audit sequence that holds up

This is the order to work in, and the order to ask a supplier to report in.

The last step is the one most teams skip. A front-end performance budget enforced in CI is what keeps LCP passing after launch. A supplier who reports only a Lighthouse score has not done steps one to three.

A competent LCP audit reports milliseconds per subpart for real mobile users. A plausible one reports a Lighthouse score and a list of compressed images.

Next step: open PageSpeed Insights on your highest-spend landing page with a UTM-tagged URL. If its TTFB is much higher than for the clean URL, fix the CDN cache key first.

1

Confirm with field data:

Pull CrUX or RUM LCP for the specific URL and device type, and check you are not reading origin-level data by mistake.

2

Identify the LCP element:

Use a DevTools trace to find out which element counts as LCP on mobile. It is often not the one the design team expects.

3

Break LCP into subparts:

Record TTFB, load delay, load duration and render delay, and compare their proportions with the ideal split.

4

Fix the server path:

Remove redirect chains, strip tracking parameters from the CDN cache key and confirm the HTML is served from the edge.

5

Fix discovery and priority:

Put the hero in the HTML as an img element, remove lazy loading from it, add high fetch priority and serve it from the same origin.

6

Clear render blockers:

Defer head scripts, trim the CSS and stop experiment tools from hiding the page.

7

Then optimize the bytes:

Serve modern formats at sizes that match the layout through an image CDN.

8

Protect the gains:

Add LCP limits to a performance budget so the next campaign template cannot quietly undo the work.

Frequently asked questions

What is a good LCP score?

A good LCP is 2.5 seconds or less, measured at the 75th percentile of real page visits. Between 2.5 and 4 seconds needs improvement, and anything above 4 seconds is poor. Judge it with field data from CrUX or RUM, not a single lab test.

Should I preload my hero image?

Preload it only if the browser cannot find it in the HTML, for example when it is a CSS background image or is added by JavaScript. If the hero is already an img element in the server-rendered HTML, adding fetchpriority=high to that element is usually enough.

Will converting images to AVIF or WebP fix LCP?

Only if resource load duration is the bottleneck. On many pages the delay comes from late discovery, slow server response or render-blocking scripts. Measure the LCP subparts first, then optimize image bytes if download time is a large share.

Why is my landing page LCP worse with UTM parameters?

If the CDN includes the full query string in its cache key, every tagged click is treated as a unique URL and misses the cache. Configure the CDN to ignore tracking parameters in the cache key so tagged visits are served from the edge.

Can lazy loading hurt LCP?

Yes. Lazy loading the LCP image always delays it, because the browser waits for layout to confirm the image is in the viewport before requesting it. Lazy load images below the fold and never the hero.

Get your hero image under 2.5 seconds

You have seen how server response, discovery, priority and CDN cache keys each add time before the hero appears. Moburst Digital Experience audits each LCP subpart on your real templates and fixes them in the build, with a performance budget so the gains last.

Talk to a performance engineer