TL;DR
If you’re seeing the “LCP Request Discovery” warning in PageSpeed Insights, it means that the element contributing most to Largest Contentful Paint (LCP)—often a hero section, banner, or featured image—isn’t discoverable early enough in the HTML, or is delayed by lazy loading. This can hurt Core Web Vitals, SEO, and user engagement.
If you’re seeing the “LCP Request Discovery” warning in PageSpeed Insights, you’re not alone.
In fact, we tested 117 WordPress websites and found that a staggering 51.2% show the exact same issue. Even ones that already use caching, CDNs, and image optimization.
The warning appears when the element that matters most for Largest Contentful Paint (LCP)—typically a hero image, featured product image, or banner—is not discoverable early enough in the HTML, or is delayed by lazy loading.
The browser waits. The page looks unfinished. Your LCP score slips.
The frustrating part is that the delay is often small. But that’s enough to push a page from a “Good” Core Web Vitals score into “Needs improvement,” impacting search visibility, user engagement, and conversions—especially on mobile.
This guide focuses on fixing that exact problem to speed up your WordPress site. Let’s go.
What “LCP Request Discovery” means
The LCP Request Discovery warning appears when the LCP element is not immediately discoverable in the HTML or is delayed by lazy loading. In other words:
- The browser cannot find the element early enough to start loading it immediately.
- Even small delays can push LCP from “Good” to “Needs improvement,” affecting Core Web Vitals, search rankings, and user engagement.
Example of the conflict in code
<img src="hero.jpg" loading="lazy" alt="Hero banner">This tells the browser:
- Do not prioritize this element
- Wait until layout and scrolling are evaluated
- Load it later
For offscreen elements, this is ideal.
For the primary above-the-fold LCP element, this delay prevents the browser from discovering and loading it promptly, triggering PageSpeed’s LCP Request Discovery warning.
Why it matters for Core Web Vitals
LCP is one of Google’s three Core Web Vitals, alongside Interaction to Next Paint (INP) and Cumulative Layout Shift (CLS). Unlike many performance metrics, LCP directly influences:
- Page Experience signals
- Search visibility
- User engagement
- Conversion behavior
This also makes LCP one of the hardest performance metrics to pass out there.
An undiscoverable LCP image often introduces an unnecessary 0.5–1 second delay. That delay alone can move a page from “Good” to “Needs improvement.”
Why this delay matters in practice
- Users see a blank or incomplete hero section
- Visual stability feels slow, even if other assets load quickly
- Bounce rates increase, especially on mobile
- Conversion funnels lose momentum at the first interaction
In short, the page technically loads, but it does not feel fast—and Google measures that feeling.
Fix all LCP issues with NitroPack
By submitting, you agree to our Privacy Policy.
How to identify the LCP image
Before fixing the issue, the correct element must be identified. Guessing often leads to partial fixes or regressions.
Lighthouse gives you a clean report without recording a full performance trace.
- Open the page in Google Chrome.
- Right-click anywhere on the page → click Inspect.
- In the DevTools panel, select the Performance tab. (If you don’t see it, click the >> menu to reveal hidden.)
- Reload the page once (if needed).
5. At the top of the Performance panel, you’ll see a Web Vitals widget showing LCP, CLS, and INP metrics.
6. Hover on the HTML snippet responsible (for example <img>, <div>, <h1>)in the LCP widget to highlight the element on the page. In NitroPack’s case, it’s a <img> element.
This method is accurate for identifying what the LCP element is. It is usually sufficient for WordPress and WooCommerce layouts.
However, it does not fully explain why the request was discovered late. For that, use the recording option in the Performance panel.
2. Record page load in Performance panel (more detailed)
The Performance panel also provides granular insight into how and when the browser discovered and loaded the LCP element.
- Open the page in Google Chrome.
- Right-click → Inspect.
- Go to the Performance tab. (If you don’t see it, click the >> menu to reveal hidden.)
- Make sure to click on “Set up” the Field Metrics (top right corner). Simply click on the button and hit OK.
- Click the Record and reload button. (bottom right corner)
- Wait until the page fully loads.
- Click Stop recording.
Once the Insights load, click on the LCP marker (usually marked in green).
You’ll see:
- The exact timestamp of the LCP event
- Option to read more about LCP breakdown
- Option to read more about LCP request discovery
This view allows you to determine whether:
- The element existed in the initial HTML
- It was injected later via JavaScript
- It was lazily loaded
- The request started late due to missing preload or priority hints
This method is best for diagnosing why discovery was delayed, which is essential for resolving the LCP Request Discovery warning properly.
How to fix the LCP breakdown warning (manually)
Manual fixes give full control, but they require precision.
The goal is simple: make the LCP element immediately discoverable in the HTML, prioritize it, and ensure it is not lazily loaded. Depending on your setup and technical comfort, there are a few ways to do this.
Option 1: Avoid lazy loading the LCP element
The most straightforward approach is to disable lazy loading for the LCP element entirely. For example:
<img src="hero.jpg" alt="Hero banner">In WordPress, lazy loading might be applied by:
- The core WordPress image handler
- Themes
- Page builders
- Optimization plugins
To fix the issue, create exclusions that prevent lazy loading for hero images or banners, featured images, the first product image on category pages, and any other content that defines LCP.
Most WordPress optimization plugins allow exclusions using CSS selectors.
Common examples:
- Hero section image
.hero-image - Featured blog post image
.wp-post-image - First WooCommerce product image
.products li:first-child img
Adding these selectors to your plugin’s lazy load exclusion field ensures the browser discovers the LCP element immediately from the HTML instead of delaying it.
This approach works — but it requires ongoing monitoring. Theme updates, layout changes, or new plugins can reintroduce lazy loading and cause the issue to return.
Option 2: Use resource prioritization with fetchpriority=”high”
Modern browsers support priority hints, which tell the browser to load critical resources first. For an LCP element, you can add:
<img src="hero.jpg" loading="eager" fetchpriority="high" alt="Hero banner">This does three things:
- Load immediately — the element is fetched as soon as possible
- Prioritize over non-critical resources — bandwidth is allocated to the LCP element first
- Make it discoverable — the browser knows this element is critical
If you’re preloading the LCP element with <link rel=”preload”>, make sure to also include fetchpriority=”high” on the preload tag:
<link rel="preload" as="image" href="hero.jpg" fetchpriority="high">This approach is cleaner than simply removing lazy loading, but may require editing theme templates or custom HTML.
The easy way: Fix LCP Breakdown automatically with NitroPack
Manual fixes work—but they scale poorly.
NitroPack removes the need to identify, tag, exclude, or prioritize images manually. It does so by analyzing each page and adapting optimizations dynamically.
How NitroPack handles LCP images
NitroPack automatically:
- Detects the LCP element per page
- Prevents lazy loading on critical images
- Applies proper fetch priority
- Preloads key assets when beneficial
All of this happens without manual rules or theme edits. Because NitroPack operates at the delivery layer, it adapts to different templates, dynamic content, page builders, and device-specific layouts.
The result is consistent LCP performance without ongoing configuration.
See NitroPack in action
By submitting, you agree to our Privacy Policy.
Bonus tips to improve LCP delivery
Fixing Largest Contentful Paint (LCP) isn’t just about one quick trick — it’s about improving each stage that contributes to the total LCP time.
Breaking it down into four key parts ensures you target the real bottlenecks:
1. Reduce Time to First Byte (TTFB)
Think of TTFB as the baseline: your LCP can’t be faster than how quickly your server starts responding.
Tips to improve TTFB:
- Choose a high-performance hosting provider
- Avoid unnecessary redirects
- Enable server-side caching
- Use a Content Delivery Network (CDN) for faster global delivery
2. Minimize Resource Load Time
Once the browser starts fetching the element, it should arrive as quickly as possible.
Techniques include:
- Compress and resize images, use WebP/AVIF
- Reduce font file sizes
- Avoid videos or heavy assets in the above-the-fold area
- Minimize CSS/JS that blocks rendering
3. Eliminate Element Render Delay
Finally, the element must render immediately after loading.
Best practices:
- Generate Critical CSS for above-the-fold content
- Defer or remove render-blocking JavaScript
- Use the font-display property for faster font swapping
This ensures your LCP element paints instantly once the resource is ready.
FAQs
What if my page has multiple LCP candidates?
Chrome chooses the element that appears first in the viewport if several are similar in size. Focus on optimizing that one.
Do landing page redirects affect LCP?
Redirects delay the first paint. Optimize the landing page to load critical elements immediately.
Do large fonts affect LCP?
Yes. Use font subsetting, preload above-the-fold styles, and set font-display: swap for faster rendering.
Does disabling lazy loading hurt performance?
No—when applied selectively. Lazy loading should be disabled only for above-the-fold content. Keeping it enabled for offscreen images remains a best practice.
Can background images be LCP elements?
Yes. CSS background images frequently become LCP elements, especially on hero sections. These require preload or priority hints, which NitroPack handles automatically.
Will fixing this warning guarantee a “Good” LCP score?
Not always. LCP depends on server response time, resource prioritization, and asset optimization. Fixing lazy loading removes one major blocker, but full optimization requires a holistic approach using the bonus techniques we mentioned earlier.
