LCP delays have four common causes: slow server responses, JavaScript or CSS blocking rendering, slow downloads of key resources, and extensive client-side rendering. Another easily overlooked cause is inappropriate loading priorities: resources downloaded early may consume bandwidth needed by more critical resources if they are not the most important content in the current viewport. When diagnosing the issue, first identify the LCP element for that page and viewport rather than assuming an image or video is the problem.
Content may be held up at different stages
Semrush lists four categories of causes that can delay the appearance of the main content, each calling for a different approach:
- Slow server responses: Response delays push back the rendering of the largest content element, so image download speed is not the only factor to consider.
- Render-blocking JavaScript or CSS: Some scripts and stylesheets prevent page content from appearing immediately. Consider deferring code that is not needed for the initial render.
- Slow resource loading: A large, high-resolution image above the fold, for example, may delay the appearance of the main content.
- Extensive client-side rendering: Requiring the browser to execute large amounts of JavaScript before displaying content may slow the initial load.
Reducing image sizes therefore will not necessarily resolve every LCP delay. If the bottleneck is the server response or render blocking, that specific stage still needs attention.
Delivery latency and server load need separate approaches
A CDN caches content on servers in multiple locations and serves it from a server near the user, which can reduce delivery latency. This improves content delivery; it does not mean a CDN will also eliminate render blocking caused by JavaScript or CSS.
Page caching can store static HTML copies to reduce repeated database queries. This approach is better suited to websites that do not rely on dynamic content and whose pages change infrequently. It should not be treated as a solution for every page.
Preloading the wrong resource can also slow down LCP
Loading critical CSS, fonts, and above-the-fold images early can reduce the wait for resources, provided they genuinely matter to the initial render. Not every resource should receive a higher priority.
web.dev provides a concrete counterexample: if a video’s poster image is the LCP element, an image preload combined with fetchpriority=”high” can raise its priority. But if the video is not the largest element in the viewport, preloading its poster may compete for bandwidth with more critical resources and delay LCP instead.
It is also important to distinguish image preloading from the video’s own preload attribute. The none and metadata values of the video’s preload attribute are only download hints, which browsers may not follow. Behavior may also differ between mobile devices, desktops, and browsers. When comparing results, keep information about measurement conditions, such as the viewport and browser, rather than applying a technique that worked on one page to every page.
LCP delays: perspectives from across the web
Does CSS for below-the-fold content also need to load immediately?
Not necessarily. First distinguish between critical CSS needed for the initial view and noncritical CSS used for below-the-fold content. Consider loading the latter after the important above-the-fold content appears. This approach applies when those styles genuinely do not affect the initial render. The aim is to reduce unnecessary waits for rendering, not to defer all CSS indiscriminately.
References
- Video performanceweb.dev — Source used in the article above.
- Largest Contentful Paint (LCP): What It Is & How to Improve Itwww.semrush.com · 2021-05-16T22:12:00Z — Discusses: Does CSS for below-the-fold content also need to load immediately?
