When configuring lazy load settings on a website, it's essential to exempt the logo, the hero image displayed at the top, and the Largest Contentful Paint (LCP) element from lazy loading. This is because if lazy load delays the download of critical visuals that are immediately visible on the screen, it can increase the LCP timing, leading users to see the first content later, which may negatively impact the Core Web Vitals score. The correct approach is to eagerly load the visuals in the initial viewport, prioritize the LCP visual, and only defer the loading of images further down the page using lazy load.
In 2026, speed optimization in SEO standards is not just about reducing the overall page size. Google pays particular attention to how quickly and stably the first visible content appears when measuring user experience. Therefore, automatically applying lazy load to every image is not a good idea. Many websites implement performance plugins, theme settings, or CDN services that add lazy loading to all img tags. While this practice may reduce the total request load in the short term, it can inadvertently yield the opposite result by delaying the loading of the logo, main product image, category banner, or the cover image of a blog post.
This guide will walk you step-by-step through the logic of making safe decisions regarding lazy load settings, why you should exempt logos and LCP images, how to implement these settings on WordPress and custom-built sites, and which metrics to monitor in testing tools. Additionally, we will explain practical considerations related to server, caching, SSL, and CDN aspects for sites hosted on the Hostragons infrastructure. If you are new to performance optimization, it may be a good starting point to check the Hostragons Web Hosting for setting up a fast hosting foundation and Hostragons WordPress Hosting for projects using WordPress.
What is Lazy Load and When Should It Be Used?
Lazy loading is a technique that prevents resources such as images, iframes, or videos from being loaded until the user scrolls close to that section on the page. The purpose is to reduce unnecessary network requests during the initial load and ensure that the browser focuses on critical content. For instance, in a 2500-word blog post with 12 images at the bottom of the page, downloading those unseen images in the first second is often unnecessary. Lazy loading lightens the initial load burden here.
However, lazy loading is not a magic speed booster. When applied incorrectly, it can disrupt the browser's prioritization system. If an image at the top of the page is lazy loaded, the browser may not treat it as a critical resource, delaying the download process, and consequently, the largest visible element of the page is painted later. This issue becomes particularly pronounced on mobile connections. For example, requesting a 200 KB hero WebP image on a 4G connection with a 700-millisecond delay can increase the LCP value from 2.2 seconds to over 3 seconds.
Suitable Resources for Lazy Load
- In-content images following the first screen of the page.
- Product images on listing pages that come after the first row.
- Images in galleries, reviews, testimonials, and portfolio sections that are lower down.
- Map, video embed areas, and social media iframe content.
- Tab or accordion content that is not visible without user interaction.
Resources That Should Be Exempt from Lazy Load
- Site logos and especially the brand image visible in the header area.
- The hero, cover, main product image, or large title image that serves as the LCP element of the page.
- Category banners or promotional images in the first visible screen.
- Critical icons and interface visuals that appear in the first screen on mobile.
- Large images used as CSS backgrounds that are included in LCP calculations.
What is an LCP Image and Why Should It Not Be Lazy Loaded?
LCP is a Core Web Vitals metric that measures how long it takes for the largest content element in the visible area of the page to load. This element is usually a large image, hero banner, product photo, blog cover image, or a large block of text on most sites. Google's good LCP target is under 2.5 seconds. Values between 2.5 and 4 seconds need improvement, while anything above 4 seconds is considered poor.
When an LCP image is lazy loaded, the browser typically follows this sequence: HTML loads, the image tag is seen, but due to lazy loading, the image is not immediately requested with high priority; JavaScript or the native lazy loading trigger comes into play; and the image starts downloading only after it is detected within the viewport. Every delay in this chain adds to the LCP timing. This delay can be exacerbated by JavaScript-based lazy load libraries when the main thread is busy.
A practical rule for 2026 is as follows: If a user can see the image as soon as the page opens or if the image carries the main message of the page, do not use lazy load. Instead, properly size the image, convert it to WebP or AVIF format, serve it responsively with srcset, and give the browser a high priority signal. Lazy load is powerful for unseen resources; it is risky for visible ones.
Why Should Logos Be Exempt from Lazy Load?
Because logos are usually small in size, some site owners may underestimate the lazy load effect on logos. However, the logo is the first signal of brand trust and an important part of the header layout. When a logo loads late, users may see a blank or broken area for a few hundred milliseconds. This can also lead to a Cumulative Layout Shift (CLS) issue. If the logo size is not fixed with HTML or CSS, a late-loading image may change the header height.
Additionally, the logo is often the first image source used across all pages in many themes. Even if it is cached by the browser, the first visit, incognito tab, new device, or CDN cache refresh can make it critical again. Therefore, keeping the logo file size between 5-30 KB, specifying width and height values, using SVG if applicable, and excluding it from lazy load is the healthiest approach.
For instance, on a corporate site with 1200 pages, if the logo is lazy loaded, the same small delay occurs on every page. Individually, 150 milliseconds may seem trivial; however, it creates a constant friction on user perception and browser metrics across the site. The logo has the lowest benefit to be gained from lazy loading compared to the highest potential loss of visual trust if loaded incorrectly.
Lazy Load Decision Table: How Should Each Image Be Loaded?
| Image Type | Location | Recommended Loading | Reason |
|---|---|---|---|
| Logo | Header, first screen | Lazy load off, eager | Critical for brand visibility and layout stability. |
| Hero or cover image | First screen | Lazy load off, high priority | Typically the LCP element on most pages. |
| Main product image | First screen of product page | Lazy load off | Critical for conversion and LCP. |
| In-content intermediary images | After the first screen | Lazy load on | Reduces initial load, loads as the user scrolls down. |
| Lower gallery images | Bottom section | Lazy load on | Defers many requests, saving bandwidth. |
| Map or video iframe | Usually bottom section | Lazy load or load on click | Delays heavy third-party resources. |
Exempting Logos and LCP Images from Lazy Load on WordPress Sites
WordPress versions 5.5 and later support native lazy loading. Additionally, performance plugins such as LiteSpeed Cache, WP Rocket, FlyingPress, Perfmatters, Autoptimize, Smush, ShortPixel, or theme-specific speed options can also add lazy load. Therefore, the source of the problem on a WordPress site may sometimes not be a single setting, but several layers of overlapping optimizations. First, determine which tool is adding lazy load.
1. Check the Source Code for the Image
Open the homepage or the page you want to optimize in your browser. Locate the logo and hero image in the page source. If the image tag has loading='lazy', data-src, data-lazy-src, or a lazyload class, this image is subject to lazy loading. For critical visuals, loading='eager' can be used, or the loading attribute can be completely removed. If the image comes as a CSS background-image, a different strategy is required; preload or CSS parsing becomes important.
2. Use the Exclusion Area in Performance Plugins
Most speed plugins have a section for Lazy Load Exclusions, Excluded Images, Skip Lazy Load, or similar. You can add a part of the logo file name, CSS class, or image URL path here. For example, if your logo file is site-logo.svg, writing site-logo in the exclusion area is usually sufficient. For the hero image, distinctive terms like hero-home.webp, featured-image, or wp-post-image can be used.
- The logo file name should be fixed and unique: like hostragons-logo.svg.
- If the hero image changes on each page, using a CSS class for exclusion is safer.
- If the featured image is the LCP, test listing pages before using the wp-post-image class in global exclusions.
- If lazy load is active in multiple plugins, only keep one active.
3. Add Eager Loading to Critical Images in the Theme Template
If you are using a custom theme, the header logo output should include loading='eager' and width-height values. For the cover image, using fetchpriority='high' is recommended if possible. This attribute signals to the browser that the image is important. However, it is not correct to give fetchpriority='high' to every image; it should only be used for one or at most two actual LCP candidates.
4. Reduce the Number of Images in the First Visible Area
Exemption does not mean placing a lot of large images in the first screen. On mobile, the first screen typically ranges from 360-430 pixels wide and 700-900 pixels high. In this area, a logo, menu, title, brief description, and one main image are sufficient. If there are four large banners in a slider, only the first slide should be eagerly loaded, while the images for subsequent slides should be lazy loaded or loaded based on user interaction.
To strengthen WordPress performance on the server side, the PHP version, OPcache, HTTP/2 or HTTP/3 support, disk speed, and server cache are also important. You can continue exploring WordPress Hosting for infrastructure preferences and Hosting Migration Guide during the site migration process.
Implementation Logic for Custom Software Sites
In React, Vue, Next.js, Nuxt, Laravel, Django, or custom PHP infrastructures, controlling lazy load is a more flexible but also more responsible process. Modern frameworks provide visual optimization components; however, one should not assume that the default settings are correct for every page. Especially in the Next.js Image component, above-the-fold images should be marked with priority or appropriate preload logic.
The fundamental principle in custom software is as follows: Critical visuals should appear early within the HTML served by the server, file sizes should be adjusted according to device width, and browser priority should be correctly assigned. If the URL of the LCP visual is not found in the HTML before JavaScript runs, the browser will delay the download. This situation is common in client-side rendering-heavy sites.
Applicable Checklist
- The logo should be presented within an img tag with width and height values.
- The LCP visual should appear early in the HTML response; it should not depend on a delayed API response.
- Lazy loading should be disabled for the first image.
- For responsive images, srcset and sizes should be used.
- If AVIF is supported, serve AVIF; if not, serve WebP, and as a last resort, optimized JPEG/PNG.
- If using a CDN, ensure the image transformation and cache duration are correctly set.
- Preload may be necessary for CSS background hero images, but avoid excessive preloading.
In custom software sites, the domain, SSL, and hosting layers also affect performance perception. To ensure a secure connection is established quickly, it is necessary to use an SSL that supports up-to-date TLS. For this, the SSL Certificate page and during the initial project launch phase, the Domain Lookup link is a natural next step.
How to Identify the LCP Image?

To make the correct exemptions, you first need to find the actual LCP element. It is necessary to measure rather than guess. This is because the LCP element on desktop may differ from that on mobile. For example, while the hero image is the LCP on desktop, the large title text might be the LCP on mobile. Or, the main product photo may be the LCP on a product page, while the visual of the first product card could be the LCP on a category page.
Check with PageSpeed Insights
The LCP element information is available in the Diagnostics section of the PageSpeed Insights report. Here, a brief preview of the relevant HTML element is visible. If the LCP element is an img, this image should be exempt from lazy load. The report may also suggest improvements like Reduce initial server response time, Properly size images, Preload Largest Contentful Paint image, and Defer offscreen images. These recommendations should be interpreted together; preloading the LCP image while indiscriminately lazy loading all images is a contradictory setting.
Check with Chrome DevTools
You can see the LCP marker by recording in the Performance panel of Chrome DevTools. Check when the visual starts being requested in the Network panel. If the critical visual comes later in the queue or is requested after JavaScript has completed, optimization is needed. If the LCP visual appears as Low in the Priority column, that is also a warning signal. In this case, fetchpriority='high', preload, or early output at the template level may be necessary.
Evaluation with Real User Data
Lab tests are important, but real user data is more valuable. The Chrome User Experience Report, Search Console Core Web Vitals report, or RUM tools show the LCP distribution under various device and connection conditions. If 75% of your users have an LCP under 2.5 seconds, you're in good shape. However, if a significant portion of mobile users is above 3 seconds, not only visual optimization but also server response time and render-blocking resources must be examined.
Common Mistakes and Solutions
Mistake 1: Automatically Applying Lazy Load to All Images
This is the most common mistake. Installing a performance plugin and enabling lazy load for all images with a single click may seem logical at first glance. However, this setting can delay logos, hero images, main product images, and sometimes even font icons. The solution is to keep the lazy load feature on while adding critical visuals to the exemption list. Going live without reviewing the images in the first screen one by one is not advisable.
Mistake 2: Incorrectly Prioritizing Slider Images
For sites using sliders, preloading all slides simultaneously is incorrect, as is lazy loading all of them. The first slide is usually a candidate for LCP and should be eagerly loaded. The second, third, and subsequent slides can be lazy loaded. Additionally, if the slider JavaScript is heavy, the LCP visual may be visually ready but still be painted late on the screen. In the 2026 design approach, a single clear hero area often performs better than a heavy slider on critical pages.
Mistake 3: Relying on Lazy Load Without Reducing Image Size
Lazy load does not optimize a 2 MB image; it only defers the download time. If the LCP image is 2 MB, simply excluding it from lazy load is not enough. The image needs to be reproduced according to its actual display size. Sending a JPEG that is 2400 pixels wide for an image that appears 390 pixels wide on mobile is unnecessary. Ideally, variations for different breakpoints should be prepared at 480, 768, 1024, and 1440 pixels.
Mistake 4: Omitting Width and Height Values
Whether the image loads late or early, the browser needs to allocate space in advance. If width and height values are missing, the browser cannot predict the space the image will occupy, which can lead to page shifts during loading. This affects the CLS metric. The size ratio must be clearly defined for logos, hero images, product visuals, and listing cards. Using aspect-ratio with CSS is also a modern and effective solution.
Recommended Implementation Plan for 2026
The following plan serves as a secure starting point for small business sites, e-commerce projects, and content-focused blogs. The goal is to defer unnecessary resources and accelerate critical ones.
- First, identify the 5 pages with the most traffic: homepage, category, product or service page, blog post, and contact page.
- Run a mobile PageSpeed Insights test on each page and note the LCP element.
- Exclude the logo, LCP visual, and first screen visuals from lazy load.
- Use native lazy loading for all remaining content images.
- Aim to keep the LCP visual under 150 KB; a maximum of 250 KB is acceptable for complex hero images.
- Prefer SVG or optimized WebP/PNG for the logo; aim to get below 30 KB if possible.
- Define width, height, srcset, and sizes for images.
- Accelerate repeat visits with CDN and browser caching.
- After making changes, monitor not just the score but also the Network timing and real user data.
When implementing this plan, if the server response time is high, visual settings alone may not achieve the target. The first part of LCP is often TTFB, the time to first byte from the server's initial response. Quality hosting, up-to-date PHP, fast databases, and the correct cache settings are therefore critical. For corporate projects, Corporate Hosting, and for high-traffic projects, VPS Server options may be considered.
Impact from a Technical SEO Perspective
Lazy load settings are one of the areas where technical SEO intersects with user experience. Search engines must be able to crawl the page, see the main content, and measure that users are having a fast experience. Native lazy loading is generally compatible with search engines; however, excessive dependency on JavaScript, images hidden within data-src, and those without a noscript alternative can pose risks for indexing or visual search visibility.
Especially e-commerce and blog sites that receive traffic from visual search must ensure that significant visuals are accessible via the real img src attribute. If the LCP visual conveys the context of the page, its alt text should also be descriptive. Alt text is not a keyword stuffing area; it should naturally describe what the visual depicts. For example, a descriptive text like "server panel showing fast web hosting infrastructure" is sufficient for the hero image on a hosting company's homepage.
Success Criteria After Testing
After configuration is complete, do not measure success with a single score. A PageSpeed score above 90 may be good, but real user LCP data might be weak. Alternatively, a lab test showing 75 might be good while field data is strong. For a healthy evaluation, monitor several metrics together.
- LCP: Should aim for under 2.5 seconds on mobile.
- CLS: Should be under 0.1; logo and visual areas should be stabilized.
- INP: Should aim for under 200 ms; heavy lazy load JavaScript should not delay interactions.
- Total visual transfer: No unnecessary megabytes should be loaded in the first screen.
- Network start time: The LCP visual should be requested shortly after the HTML.
It is ideal to test changes first in a staging environment. If changes need to be made on the live site, clear the cache, check the CDN cache refresh, and examine whether there are visual breaks on different devices. If there is a misconfiguration in the SSL, CDN, or cache layer, the old version may be presented instead of the optimized visual. For secure and up-to-date publishing, technical content like SSL Certificate Installation and What is CDN can be beneficial.
Brief Implementation Summary
When configuring lazy load settings on a website, the primary goal is to defer unseen visuals and accelerate visible critical ones. The logo, hero image, main product image, and the actual LCP element should be exempt from lazy load. In contrast, in-content images, lower gallery images, maps, and videos are suitable for lazy load. To achieve good results, visual format, sizing, srcset, caching, CDN, and hosting performance should be considered together.
With the correct configuration, users will see the first content faster, the brand area will load without delay, and the potential for improvement in Core Web Vitals will increase. If you want to strengthen your site's infrastructure with a performance focus, you can explore Hostragons’ hosting, WordPress hosting, SSL, and server solutions; and start with a small but effective step by testing the exemptions for the logo and LCP visual on your existing site.
Frequently Asked Questions
What happens if the logo is lazy loaded?
If the logo is lazy loaded, delays, blank images, or layout shifts may occur in the header area. Since the logo is a small file, the benefit gained from lazy loading is low; it is more appropriate to exempt it for brand visibility and CLS.
How can I find the LCP image?
You can check the LCP element section in the PageSpeed Insights report or record in the Chrome DevTools Performance panel. Separate tests should be conducted for mobile and desktop, as the LCP element may vary depending on device width.
Should I give fetchpriority high to every top section image?
No. fetchpriority='high' should only be used for critical visuals that are actual LCP candidates. Giving high priority to too many resources can weaken the browser's prioritization system and reduce the expected speed increase.
Does lazy load harm SEO?
If implemented correctly, it does not harm; in fact, it can enhance user experience by reducing page load. However, lazy loading critical visuals, excessive dependency on JavaScript for image loading, and inaccessible img sources can lead to technical SEO issues.
Which images should I exclude in WordPress?
The header logo, homepage hero image, blog post cover image, main product image on the product page, and elements identified as LCP in the PageSpeed report should be excluded. Lazy load can remain active for the remaining content images.