ThisCalculator

Everyday

Mobile LCP Hero Images: Find the Delay Before You Optimize

Updated · Standard formula, shown below

This article explains how to find the delay caused by a hero image on your mobile page before you optimize it. You will learn the exact steps to measure the image’s impact on Largest Contentful Paint (LCP) using browser DevTools and online tools, and how to interpret the results to know whether the image is the bottleneck or just a symptom.

What LCP Hero Image Delay Means

Largest Contentful Paint (LCP) is a Core Web Vital that measures when the largest visible content element (often a hero image) finishes rendering. The delay you’re looking for is the time between when the browser starts loading the page and when that hero image becomes visible. This delay is not a single number; it’s a combination of several sub-phases: Time to First Byte (TTFB), resource load delay, and the image’s own download and decode time. For a hero image, the critical part is usually the load time of the image file itself, but the delay also includes any JavaScript or CSS that blocks rendering before the image is even requested.

To find the delay, you need to measure the LCP element’s timing breakdown. The browser’s Performance panel shows you exactly when the image was discovered, when the request started, when the response ended, and when the image was decoded and painted. The difference between the navigation start and the LCP time is the total delay. The difference between the request start and the response end is the network delay. The difference between the response end and the LCP time is the decode and render delay.

How to Measure the Delay in Chrome DevTools

Chrome DevTools is the most direct way to find the hero image delay on a live page. Here’s the step-by-step process:

  1. Open the page in Chrome on a mobile emulation profile (or use a real device via remote debugging).
  2. Open DevTools (F12), go to the Performance panel, and click the record button.
  3. Reload the page and stop recording after the page is fully loaded.
  4. In the recorded trace, look for the Timings section. You’ll see a marker labeled LCP with a timestamp.
  5. Click on that LCP marker. In the bottom panel, you’ll see the LCP element’s details, including the image URL and its render time.
  6. In the Network panel (or the same trace), find the image request. Note the Queueing, Stalled, Request sent, Waiting (TTFB), Content Download times.
  7. The sum of these network phases plus the time from the response end to the LCP paint is your hero image delay.

For a quick check without recording, you can use the Network panel alone: reload the page, find the hero image request, and look at the Waterfall column. The horizontal bar shows the time from the request start to the response end. The gap between the navigation start and the request start is the delay before the image was even requested (often due to render-blocking CSS or JS).

Using Lighthouse to Isolate the Delay

Lighthouse gives you a higher-level view. Run a Lighthouse audit on your mobile page (in DevTools, or via PageSpeed Insights). In the Opportunities section, look for Properly size images, Serve images in next-gen formats, and Efficiently encode images. These tell you how much time could be saved by compressing or resizing the image. But Lighthouse doesn’t directly tell you the LCP delay; it gives you an estimated savings for each image optimization.

To get the actual LCP delay, you need to combine Lighthouse with the Performance panel. Lighthouse shows you the LCP time, but not the breakdown. The Performance panel gives you the breakdown. A common workflow is: run Lighthouse to see if LCP is failing (e.g., over 2.5 seconds), then use the Performance panel to see how much of that time is the hero image.

Common Causes of Hero Image Delay

Once you have the timing breakdown, you can identify the cause. Here are the most common issues and how they appear in the trace:

  • Render-blocking CSS/JS: If the image request starts late (after 1-2 seconds), the page is probably blocked by external stylesheets or synchronous scripts. The trace will show a long gap between navigation start and the image request.
  • Slow TTFB: If the Waiting (TTFB) for the image is long (over 500ms), the server is slow to respond. This could be due to server location, database queries, or lack of caching.
  • Large image file: If the Content Download time is long (over 1 second on 4G), the file is too big. A typical hero image should be under 200KB.
  • Unoptimized format: If the image is a PNG or old JPEG, it may be larger than a WebP or AVIF version. The trace will show a long download time for a large file.
  • Lazy loading: If you use loading="lazy" on the hero image, it may not start loading until the browser thinks it’s near the viewport, which can delay LCP. The trace will show the request starting late.

How to Reduce the Delay (After You Find It)

Once you know the delay, you can optimize. The most effective fixes are:

  1. Preload the hero image: Add <link rel="preload" as="image" href="hero.webp"> in the head to make the browser request it earlier.
  2. Remove render-blocking resources: Inline critical CSS or defer non-critical scripts so the image request starts sooner.
  3. Serve a compressed, modern format: Convert to WebP or AVIF, and ensure the file is sized to the actual display width (e.g., 1200px, not 4000px).
  4. Use a CDN: A Content Delivery Network reduces TTFB by serving the image from a server close to the user.
  5. Set explicit dimensions: Add width and height attributes to prevent layout shift, which doesn’t directly reduce delay but helps LCP stability.

After making changes, re-run the Performance trace and compare the LCP marker. You should see the request start earlier and the download time shrink.

Comparing Tools: DevTools vs. WebPageTest vs. PageSpeed

Each tool gives you a different view of the delay:

  • Chrome DevTools: Best for a granular, step-by-step trace. You see every network request and its timing. Good for debugging specific issues.
  • WebPageTest: Shows a filmstrip of the page loading, plus a waterfall of all requests. It also gives a LCP breakdown in the Core Web Vitals tab, showing the TTFB, load delay, and load time for the LCP element. This is often easier to read than DevTools.
  • PageSpeed Insights: Uses Lighthouse. It gives you a score and lists opportunities, but not the raw timing breakdown. Good for a quick check and for seeing the estimated savings of each optimization.

For a definitive answer, use WebPageTest’s LCP breakdown. It explicitly shows TTFB, Load Delay, Load Time, and Render Delay for the LCP element. That’s the exact delay you’re looking for, without needing to interpret the trace yourself.

Common Misconception: The Image Isn’t Always the Problem

Many developers assume that a large hero image is the sole cause of a slow LCP. But often the image is fine; the delay comes from the server response or render-blocking scripts. For example, if your TTFB is 2 seconds, the image request won’t even start until after that. Optimizing the image to a tiny file won’t help if the request starts late. The Performance panel will show this clearly: the image request will have a long Queueing or Stalled time, but the Content Download will be short. In that case, you need to fix the server or remove blocking resources, not the image.

Frequently Asked Questions

What is a good LCP time for a hero image?

Google recommends an LCP of 2.5 seconds or less for 75% of page visits. The hero image itself should ideally load within 1 second of the request. If your total LCP is over 2.5 seconds, and the image download takes more than 1 second, that’s a significant delay.

Does lazy loading hurt LCP?

Yes, if you apply loading="lazy" to the hero image. The browser will not start downloading the image until it’s close to the viewport, which can delay LCP. For the hero image, you should use fetchpriority="high" and not lazy load it.

How do I see the LCP element in DevTools?

In the Performance panel, after recording, click on the LCP marker in the Timings section. The bottom panel will show the element’s details, including the image URL, its dimensions, and the exact time it was painted.

What is the difference between TTFB and LCP delay?

TTFB (Time to First Byte) is the time from the request to when the server sends the first byte of the HTML. LCP delay is the total time from navigation start to when the largest element paints. TTFB is one component of LCP, but LCP also includes the time to load the image and render it.

Is WebP always better for hero images?

WebP is generally smaller than JPEG or PNG for the same quality, but not always. For photos, WebP can reduce size by 25-35% compared to JPEG. AVIF can be even smaller. But if your image has sharp edges or text, PNG might be better. Always test the actual file size.

Can I fix LCP delay with a plugin?

Some WordPress plugins or CDNs can automatically compress images and add preload tags. However, they won’t fix a slow server or render-blocking CSS. You need to find the root cause first, then use a plugin if it addresses that specific issue.

Related

Method: the standard formula for this calculation, rounded as each result states. See how the calculators work or report an error.