Skip to content
Faisal Mahmud TusherDigital marketing, SEO & analytics
with Faisal Tusher

SEO › Troubleshooting

LCP Issue: Longer Than Allowed

Why Search Console flags a slow Largest Contentful Paint and how to fix it: server response, render-blocking resources, heavy hero images and late loading.
Troubleshootingintermediate6 min readUpdated

First, confirm with field data and name the element

The Core Web Vitals report in Search Console (GSC) is built from field data: measurements from real Chrome users, gathered in the Chrome UX Report, and grouped into URLs that behave alike. Open the mobile and desktop tabs separately, click the LCP issue, and note the URL group and its example pages. A group usually maps to a template, such as product pages or blog posts, which is where the fix belongs.

Then move to diagnosis tools. PageSpeed Insights shows the field figures for an example URL beside a lab run, and its diagnostics name the largest contentful paint element. Lab results vary with device and network and will not match the field exactly; use them to find the cause, and the field data to judge the outcome. In the browser's performance panel, the LCP breakdown splits the time into time to first byte, resource load delay, resource load duration and element render delay. Whichever phase is largest decides the row of the table to read. Remember that field data is collected over a rolling window, so a fix shows in the report only after enough new visits have been measured.

Diagnosis table

Diagnosis

SymptomCheckLikely causeFix
Time to first byte takes up most of the LCP timeServer timing; caching headers; TTFB in field and labSlow server response before anything rendersCache pages, use a CDN, speed up the backend and remove redirect hops
The element waits while stylesheets and scripts downloadRender-blocking resources listed in diagnostics; waterfall orderRender-blocking CSS and scriptsInline critical CSS, defer non-critical scripts, trim unused code
The hero image download dominates the breakdownImage file size, format and dimensions against the displayed sizeOversized or unoptimised hero imageServe a right-sized, modern-format image with responsive sources
Long resource load delay; the image request starts lateLazy-loading attribute on the element; where the URL is discoveredLCP image lazy-loaded or discovered lateLoad the hero eagerly, reference it in HTML, add a preload or priority hint
Long render delay; the element appears only after scripts runRendered versus initial HTML; framework hydration timingContent rendered client-side after JavaScript runsRender the first view on the server or statically
Main thread and network busy with tags before the element paintsThird-party requests and long tasks in the performance traceThird-party scripts competing for the main thread and networkRemove, delay or lazy-load non-essential tags; self-host what must stay

Fix, verify and prevent each cause

Slow first response

Nothing can paint before the HTML arrives, so a slow backend delays everything after it. Uncached pages built from heavy database queries, distant origins and redirect hops before the final URL are typical.

Fix: cache full pages where content allows, serve from a CDN close to visitors, profile and speed up the slow queries, and link directly to final URLs.

Verify: time to first byte falls in lab runs from several regions, and the field figure follows.

Prevent: track server response time per template as a standing metric, as the template-level approach in Core Web Vitals recommends.

Stylesheets and scripts blocking the render

The browser will not paint until it has processed the stylesheets in the head and any synchronous scripts. Large framework bundles and unused CSS lengthen that wait even when the hero image arrives early.

Fix: inline the CSS needed for the first view, load the rest asynchronously, defer or move scripts that are not needed to paint, and remove unused code.

Verify: the render-blocking diagnostic clears, and the render delay phase shrinks in the trace.

Prevent: set a budget for blocking resources in the build pipeline, so a new library cannot slip into the head unnoticed.

A heavy hero image

A photograph exported at print resolution, or a desktop image sent to phones, makes the download phase long even on fast connections.

Fix: resize to the largest displayed size, use a modern format, compress sensibly and offer responsive sources so each device gets an appropriate file.

Verify: the resource load duration phase drops and the transferred size of the LCP image is in line with the displayed size.

Prevent: handle resizing and format conversion automatically through an image pipeline or CDN, following the format and transformation advice in image SEO.

The hero is found late or lazy-loaded

Lazy loading is right for images below the fold and wrong for the first one. Images set as CSS backgrounds, inserted by a carousel script, or loaded only after a component mounts are found late as well.

Fix: load the LCP image eagerly, reference it in the HTML with an image element, and add a preload or fetch priority hint where the browser cannot discover it early.

Verify: in the waterfall, the image request starts with the first batch of resources and the load delay phase collapses.

Prevent: configure components so the first image on a template is never lazy-loaded, the rule set out in the lazy loading section of the image SEO guide.

First view rendered by JavaScript

When the server sends an empty shell and the framework builds the page in the browser, the LCP element cannot paint until the bundle has downloaded, parsed and run.

Fix: move to server-side or static rendering for the content in the first view, and hydrate interactive parts afterwards.

Verify: the LCP element is present in the initial HTML and the render delay phase is small.

Prevent: choose rendering strategies per template with performance in mind, using the comparison in JavaScript SEO.

Third-party tags crowding the page

Chat widgets, tag managers, testing tools and ad scripts download and execute alongside your own code. Some hide the page until they finish.

Fix: inventory every tag, remove the ones nobody uses, delay others until after the first paint or user interaction, and avoid anti-flicker snippets that hide content.

Verify: third-party transfer and long tasks before the LCP fall in the trace.

Prevent: require an owner and a performance review for every new tag, as described in the third-party scripts section of Core Web Vitals.

Prevention: performance budgets per template

LCP regressions arrive with ordinary releases: a bigger hero, a new font, a marketing tag. Give each template a budget for server response, blocking resources, hero image weight and third-party scripts, and check it in continuous integration with a lab tool on a throttled mobile profile. Review the Search Console report monthly by URL group and investigate any group that changes status. Google's page experience documentation presents Core Web Vitals as part of a wider set of signals, so performance work supports SEO without replacing relevance; it also helps conversion, which is reason enough to keep the budget. Speed issues are separate from markup problems; if the same pages also lost their enhanced listings, the sibling page on rich results not showing covers that diagnosis.

Illustrative example — not a real result

A furniture shop's product template on mobile

A furniture retailer's mobile product pages sit in a "poor" LCP group of 3,800 URLs, with field LCP around 4.6 seconds. The trace on an example page shows time to first byte of 0.6 seconds, resource load delay of 2.1 seconds and a 900 KB hero image. The delay comes from a gallery script that lazy-loads every image, including the first. The team loads the first image eagerly with a high fetch priority and serves a 120 KB responsive version. Lab LCP drops to 2.0 seconds, and over the next four weeks the field group moves to "good".

Loading speed is only part of the experience Google asks about; the page experience guide covers the overlays, ad placement and mobile display that often slow the same templates.

Common mistakes

Optimising the lab score while the field data stays poor. Fixing one URL instead of the template behind the group. Compressing the hero image when the real delay is late discovery. Expecting the report to change the day after a release.

Frequently asked questions

Why does PageSpeed Insights show a good score while Search Console says poor?

The score is a lab test on one simulated device, while Search Console uses field data from real visitors over a period of time. Real users may have slower phones and networks. Use the lab to find causes and the field data to judge success.

Why has the report not changed after my fix?

Field data is collected over a rolling window, so improvements appear gradually as new visits replace old ones. Confirm the fix in lab tests straight away, then watch the field figures over the following weeks before deciding whether it worked.

Does a slow LCP stop my pages ranking?

Google describes Core Web Vitals as part of its page experience signals, alongside many others, and relevance still matters most. A slow LCP will not on its own remove a relevant page from results, but it affects visitors and conversion, which makes it worth fixing.

Terms used on this page

Where this page is used

Also related

Sources

  1. Understanding Core Web Vitals and Google search results — Google Search Central
  2. Understanding page experience in Google Search results — Google Search Central

Related