Optimize the LCP Resource Load Delay

The second part of LCP: the wait until the browser requests the LCP image. Close to zero when that image is an img tag in the HTML and not lazy-loaded.

  • Good ≤ 2.5 s
  • Needs improvement ≤ 4 s
  • Poor > 4 s
Arjen Karel
Updated · 10 min read
Share

Resource load delay in short

Resource load delay is the second of the four parts of Largest Contentful Paint (LCP): the time from the first byte of the HTML until the browser starts downloading the LCP image. It is long when the browser finds the image late or holds it back, and close to zero when the image is an <img> in the HTML without loading="lazy".

Where does resource load delay start and end?

Resource load delay follows time to first byte and lasts until the browser sends the request for the LCP image; the download after that request is the resource load duration. An image LCP has four parts, one after the other: time to first byte, resource load delay, resource load duration and element render delay. Resource load delay and element render delay are both waits: resource load delay comes before the request for the image, and element render delay comes after the download, until the image is painted.

Timeline of a page load: the time to first byte, then a stylesheet and a script; the resource load delay runs from the first byte of the HTML until the browser requests the image, and the image download follows

An image the browser finds only after a stylesheet and a script is requested late.

Lighthouse 13 and Chrome DevTools call this part Resource load delay (Load Delay in Lighthouse 12), CrUX calls it Resource Load Delay, the web-vitals library resourceLoadDelay and CoreDash Load Delay.

Why does the browser request the LCP image late?

The browser requests the images it finds in the HTML while the HTML is still arriving: Chrome's preload scanner reads ahead and requests every <img> it sees, except the lazy ones. An LCP image in a stylesheet, in a style attribute, in a slider script or with loading="lazy" waits for that stylesheet, the layout or the script, and that wait is the resource load delay.

On a test page, a hotel home page built like a WordPress site with a page builder, the same photo was placed in seven ways and loaded on Slow 4G with a 4x slower CPU:

The photo isLoad delayLCP
an <img> with fetchpriority="high"0.012.02
a background, with a preload0.012.03
an <img> with loading="lazy"1.153.64
a background in the stylesheet1.133.62
a background in a style attribute1.124.16
an <img> a lazy-load script fills in1.863.98
a slide a slider script builds1.854.63

Medians of five loads, in seconds. The first byte of the HTML arrived at 0.58 s every time. Every version loaded the same 63 kB photo, except the style attribute, which can't switch to the smaller phone file.

Found in the HTML, the photo was requested within 10 ms; every other version waited for the first paint at about 1.7 s or for a script at about 2.4 s.

A photo the browser has found can still wait behind the stylesheets and scripts in the head; fetchpriority="high" gives it High priority from the start, ahead of async and deferred scripts.

Lighthouse flags a late LCP image request in its LCP request discovery notice, "Optimize LCP by making the LCP image discoverable from the HTML immediately, and avoiding lazy-loading". Its check "Request is discoverable in initial document" fails when a stylesheet or a script starts the request, and "LCP resources shouldn't use loading=lazy" fails for a lazy LCP image, which waits for the layout.

How long should the load delay be?

Resource load delay can be close to zero: an <img> in the HTML, not lazy, is requested within milliseconds of the first byte. According to the State of Web Vitals, resource load delay is the largest part of LCP on phones on 21.9% of the sites with an image LCP and all four parts in CrUX.

CoreDash measured real visitors' phone page loads with an image LCP on 122 projects in the 28 days up to 7 November 2026: their resource load delay was 350 ms at the 75th percentile. On the loads with an LCP of 2.5 seconds or more it was about 1.2 seconds, against 0.3 seconds on the faster ones.

Compressing the LCP image is the fix people try first, and on most sites it shortens the smallest part. The time to first byte is usually the largest part, so compare all four parts of LCP first.

How do you measure resource load delay?

Start with real visitors: CrUX reports the resource load delay of image LCPs at the 75th percentile, and a real-user monitoring tool such as CoreDash splits it per page, element and way the image was loaded. A trace in Chrome DevTools then shows what the image waited for.

CrUX

In CrUX Vis, enter your site, open Loading performance and pick Largest Contentful Paint (LCP) image subparts.

CrUX Vis, LCP image subparts at the 75th percentile over time for desktop page loads: Time to First Byte, Resource Load Delay, Resource Load Duration and Element Render Delay as four lines

CrUX Vis, Loading performance: the orange line is Resource Load Delay; each weekly point covers the 28 days before it.

CoreDash

In CoreDash, open the LCP breakdown on mobile and pick LCP Priority under More dimensions. Each row is one way the LCP image was loaded, and the green part of its bar is the load delay. Group by URL to find the template where it is long, and check the LCP element type per page: a text LCP has no load delay to fix.

CoreDash, LCP subparts by LCP Priority on mobile, p75: rows for Preloaded, Not preloaded, High fetchpriority and Lazy loaded, each with a bar split into its subparts, load delay in green

CoreDash on mobile: even the High fetchpriority row is mostly load delay, because fetchpriority only helps once the browser has found the image.

Chrome DevTools

Record a trace in the Performance panel with mobile throttling and open LCP breakdown in the Insights sidebar: its Resource load delay row is this part. LCP request discovery, in the same sidebar, says "LCP image loaded ... after earliest start point"; despite the word loaded, that time is the load delay.

Chrome DevTools Performance panel: the LCP request discovery insight with LCP image loaded 1,552 ms after earliest start point, and in the Network track a striped bar from the HTML to the start of terrace-caldera-768.jpg, which begins after the stylesheets

The hotel test page with the photo in the page builder's stylesheet: the striped bar is the wait before the photo's request.

In the Network panel, the Initiator column next to the image names the file that requested it, and the Priority column (right-click a header to add it) shows whether it went out at Low, Medium or High.

PageSpeed Insights takes its LCP breakdown rows from a fast, unthrottled load (why the rows differ), and a Lighthouse run with DevTools throttling counts part of the HTML's own wait as load delay. Compare lab runs with each other, and take the real value from field data.

The web-vitals library

The attribution build of web-vitals logs the load delay of each page load with its image and element:

<script type="module">
  import { onLCP } from 'https://unpkg.com/web-vitals@6/dist/web-vitals.attribution.js?module';

  onLCP(({ value, attribution }) => {
    console.log('LCP', value, 'load delay', attribution.resourceLoadDelay);
    console.log('image', attribution.url, 'element', attribution.target);
  }, { reportAllChanges: true });
</script>

Which cause is it on your page?

A long load delay usually means the LCP image is found late or held back with loading="lazy". Otherwise it waits behind other files, or comes from another domain.

What you seeWhy it waitsWhere to look
A section or page-builder backgroundThe stylesheet and the layoutInitiator: a .css file
loading="lazy" on the heroThe layoutThe <img> in the page source
A lazy-load plugin moved the URLThe plugin's scriptdata-src in the page source
A slider, an A/B test or React builds the heroThe scriptInitiator: a .js file
The <img> is in the HTML, at Low or MediumFiles ahead of it in the headPriority column
fetchpriority="high" on another imageThe hero gets MediumWhich <img> has it
A preload without fetchpriority, or for another URLLow, or a second downloadTwo requests for one photo
The <img> far down a heavy HTMLThe HTML before itInline SVG, JSON or CSS above it
The photo on another domainA connection of its ownThe domain in the image URL

A theme or CMS image block that sets loading="lazy" on every image lazy-loads the hero too. Give the first image an exception.

How do you reduce resource load delay?

There are two ways to reduce resource load delay: make the LCP image more important, or make the rest less important. The first means the photo as an <img> in the HTML, without loading="lazy", with fetchpriority="high" on that one image; the second means fewer files ahead of it. A preload is for an image the HTML can't name; an image the HTML can name goes in the HTML.

<img src="/img/hero.webp" alt="..." width="1200" height="600" fetchpriority="high">

WordPress and page builders

WordPress keeps the first images out of lazy loading and gives the first large one fetchpriority="high". When the load delay stays long, a plugin or the theme usually overrides that:

  • WP Rocket: Optimize Critical Images, on by default, preloads the LCP image with high priority and keeps it out of LazyLoad.
  • Perfmatters: set Exclude Leading Images to the images in the first screen on a phone, often one.
  • LiteSpeed Cache: switch on Viewport Images, or add the photo's file name to Lazy Load Image Excludes.

Keep one lazy loader: with two, the photo stays lazy after you exclude it in one. Upload the logo at the size it shows, so fetchpriority="high" goes to the photo. In Elementor, use an Image widget for the hero instead of a Container background, and make the first slide a plain image. In the Cover block, switch off Fixed background, which turns the photo into a background. My plugin WP Core Web Vitals learns the LCP image per screen size from your visitors and loads it first, with high priority. LCP request discovery has the settings for more plugins.

Shopify

Dawn, Horizon and the themes built on them give the image in a template's first section fetchpriority="high" and no lazy loading, so make the banner or slideshow the first section. On a Dawn product page the main photo lacks fetchpriority: add it in product-thumbnail.liquid. A hero an app builds with JavaScript starts late whatever the theme does: use a theme section.

Next.js and React

In development, Next.js warns about a lazy hero: "Image with src ... was detected as the Largest Contentful Paint (LCP). Please add the `loading="eager"` property if this image is above the fold." By default next/image lazy-loads, and since Next.js 15, priority (preload in Next.js 16) makes the image eager and preloads it without fetchpriority. Set loading and fetchPriority yourself:

<Image src={hero} alt="..." sizes="100vw" loading="eager" fetchPriority="high" />

A hero React renders in the browser exists only after the JavaScript has run: render it on the server.

A background that has to stay a background

Replace the background with an <img> first: object-fit makes it fill the space the way the background did.

<section class="hero">
  <img class="hero-img" src="hero-1600.jpg" srcset="hero-768.jpg 768w, hero-1600.jpg 1600w"
    sizes="100vw" width="1600" height="900" alt="..." fetchpriority="high">
</section>
.hero { position: relative; }
.hero-img { position: absolute; inset: 0; width: 100%; height: 100%; object-fit: cover; }

When it must stay a background, preload the file the stylesheet picks per screen size, with the stylesheet's media queries and fetchpriority="high", in that page's template only:

<link rel="preload" as="image" href="hero-768.jpg" media="(max-width: 767px)" fetchpriority="high">
<link rel="preload" as="image" href="hero-1600.jpg" media="(min-width: 768px)" fetchpriority="high">

A preload without fetchpriority="high" is requested at Low, lower than the same image as an <img>. A preload for another URL than the page uses downloads the photo twice; for an <img> with srcset, copy its srcset and sizes into the preload's imagesrcset and imagesizes.

Fewer files before the photo

Everything above the photo in the HTML competes with it for bandwidth:

  • A script the first screen doesn't need, such as a chat widget, goes to the bottom of the page. No one in the history of the internet has ever needed to chat before the page was visible.
  • Hidden images at the top (language flags, menu images, the slides after the first) get loading="lazy". Visible first-screen images that are not the LCP image, such as an avatar, get fetchpriority="low".
  • Preloads for files the site no longer uses go, and on a listing page only the first photos load eagerly.
  • Preconnects to ad networks take bandwidth from the LCP image: add them only once that image is in the HTML, not lazy, with fetchpriority="high".
  • Preloads go after the stylesheets and before the scripts in the head.
  • Render-blocking stylesheets stay around 15 kB each, compressed, and large inline SVG, JSON or CSS stays out of the top of the HTML.

On a busy page, where the photo competes with dozens of scripts and stylesheets, I have measured up to 30% faster LCP with fetchpriority="high". Google measured a drop from 2.6 to 1.9 seconds on Google Flights.

An image on another domain

An LCP image on another domain waits for a connection of its own. Move it to your own domain; add a preconnect only when you can't.

A hero you can't change

When an A/B test or a widget swaps the hero and its URL stays the same, a preload with fetchpriority="high" in your own template starts it early. On a slow server, 103 Early Hints can start the photo before the HTML arrives, when it is the same file on every screen. Both take a developer.

Did the LCP image start earlier?

In a new trace the photo's request starts right after the HTML, and LCP request discovery shows three green checks. For real visitors, the load delay on phones in CoreDash drops within days on the pages you changed; Search Console takes up to 28 days.

Run Lighthouse again and compare all four parts: the wait can move to the next part. On a test page built like an estate agent's WordPress site, the photo in the HTML took the load delay from 2.02 to 0.01 seconds; after the next fix, WebP at phone size, 1.9 seconds moved into element render delay, because an entrance animation held the photo back.

When a builder, slider, app or A/B tool places the photo with no setting to change it, or the load delay on phones stays long with three green checks, book a Core Web Vitals power hour: we compare your field data with a trace of your slowest template and decide which change gets the photo requested with the HTML.

About the author

Arjen Karel is a web performance consultant and the creator of CoreDash, a Real User Monitoring platform that tracks Core Web Vitals data across hundreds of sites. He also built the Core Web Vitals Visualizer Chrome extension. He has helped clients achieve passing Core Web Vitals scores on over 925,000 mobile URLs.

Arjen Karel

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
Arjen Karel
Arjen Karel, Web performance consultant since 2009

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 URL

No developer to build the fix? I do the work myself, on a copy of your site.

Arjen KarelLCP still red on mobile?Send me your URL