Skip to content
🎓 Practical SEO training for real online projects ▶♪f𝕏

LCP Optimization Best Practices 2026: Get Under 2.5 Seconds (Step-by-Step Guide)

✍️ By 📅 ⏱ 11 min read

Quick answer: LCP optimization best practices in 2026 come down to one idea: treat 2.5 seconds as a budget and spend it wisely. Split your Largest Contentful Paint into four parts (server response, discovery delay, download time and render delay), find the part that is eating the budget, and fix that part first. For most sites, the biggest wins come from a faster server response and making the browser find the LCP image early, not from compressing images harder.

This guide is different from the usual “15 tips” list. We will walk through LCP like a stopwatch. You will measure, find the slow part, fix it, and check again. Each step has a clear target in milliseconds, so you always know if you are winning.

What LCP Measures (and the Target You Need to Hit)

Largest Contentful Paint is the time from when a visitor starts loading your page until the biggest image or text block in the visible screen appears. Google wants this to be 2.5 seconds or less for at least 75% of page visits. That “75%” part matters. One fast test on your office Wi-Fi does not count. Real visitors on real phones decide your score.

LCP score (75th percentile) Google rating What it means
0 to 2.5 seconds Good Passes Core Web Vitals for loading
2.5 to 4.0 seconds Needs improvement Visitors feel the wait
Over 4.0 seconds Poor High bounce risk on mobile

Is LCP a ranking factor? Yes, but it is one of many. A fast page will not beat a page with far better content. Still, when two pages are close, speed and page experience can tip the balance. It also affects how many people stay long enough to read, buy or call you. If your site has dropped recently, also read our breakdown of the October 2026 Google ranking update before you blame speed alone.

The 2.5-Second Budget: Where Your Time Really Goes

Every LCP time can be broken into four subparts. There is no gap and no overlap between them. Added together, they equal your full LCP.

  1. Time to First Byte (TTFB): the time until the browser gets the first byte of your HTML.
  2. Resource load delay: the gap between TTFB and when the browser starts downloading the LCP image.
  3. Resource load duration: how long the LCP image takes to download.
  4. Element render delay: the time between the image finishing and it actually showing on screen.

Google’s Chrome team studied real-world data from the Chrome UX Report and found something surprising. Here are the median 75th-percentile numbers for pages where the LCP element is an image:

Site group TTFB Load delay Load duration Render delay
Good LCP 600 ms 350 ms 160 ms 230 ms
Needs improvement 1,360 ms 720 ms 270 ms 310 ms
Poor LCP 2,270 ms 1,290 ms 350 ms 360 ms

Look at the “Load duration” column. The difference between good and poor sites is only about 190 ms. Now look at TTFB and load delay. Poor sites lose well over 2.5 seconds there alone. The median site with poor LCP waits about 1.3 seconds before it even starts downloading the LCP image. That is more than half the whole budget gone before a single byte of the image arrives.

Lesson: image compression is good, but it is rarely the main problem. Server speed and late discovery usually are.

A Simple Budget to Aim For

Subpart Target budget Share of 2.5 s
TTFB 800 ms or less ~32%
Resource load delay Under 250 ms (ideally near 0) ~10%
Resource load duration Under 1,000 ms on 4G ~40%
Element render delay Under 250 ms ~10%
Safety margin ~200 ms ~8%
LCP optimization best practices 2026 performance analytics on a laptop screen
Photo by lukechesser on Unsplash

Step 1: Measure Your Real LCP (Field Data First)

Before you change anything, get a baseline. Use two kinds of data:

  • Field data (real users): open PageSpeed Insights and look at the top section, “Discover what your real users are experiencing.” Also check the Core Web Vitals report in Google Search Console. This is the data Google uses.
  • Lab data (one test run): the Lighthouse section in PageSpeed Insights and Chrome DevTools. Use it to debug, not to judge success.

Write down three numbers for your most important templates (home page, blog post, product page): LCP, TTFB and the LCP element type (image or text). If Search Console shows no data, your site may not get enough Chrome traffic yet. In that case, lab tests are all you have, so test on “Mobile” with throttling on.

Step 2: Find Your LCP Element and Its Slowest Subpart

You cannot fix what you cannot see. Here is a quick way to find the LCP element:

  1. Open your page in Chrome and press F12 to open DevTools.
  2. Go to the Performance panel. Live metrics show your LCP and the element right away.
  3. Click the LCP element link. Chrome highlights it on the page.
  4. Record a page load and open the LCP insight. It shows the four subparts in milliseconds.

In PageSpeed Insights, the “LCP breakdown” insight shows the same split. Now compare your numbers with the budget table above. The subpart that is furthest over budget is where you start. Do not fix all four at once. Fix the biggest one, then measure again.

Step 3: Cut TTFB Below 800 ms

If TTFB is your biggest problem, no front-end trick can save you. A TTFB of 2 seconds leaves only half a second for everything else. Fix the server side first:

  • Use full-page caching. On WordPress, a caching plugin (or server-level cache like LiteSpeed or Nginx FastCGI) serves ready-made HTML instead of building every page with PHP and database calls.
  • Add a CDN with HTML caching. If your visitors are in the US or UK but your server is in Asia (or the reverse), a CDN moves your pages closer to them. This one change often cuts hundreds of milliseconds.
  • Remove redirect chains. Every redirect adds a full round trip. Link straight to the final URL, including the correct “https” and “www” version.
  • Upgrade weak shared hosting. Cheap hosting with slow CPUs shows up as high TTFB even with caching on.
  • Watch URL parameters. Tracking parameters like UTM tags can bypass cache on some setups. Make sure your CDN ignores them for caching.
  • Use HTTP/2 or HTTP/3. Most good hosts and CDNs support HTTP/3 now. It helps most on slow mobile networks.

Re-test after each change. Your target is a field TTFB of 800 ms or less.

Web code on a computer screen for LCP optimization in 2026
Photo by afgprogrammer on Unsplash

Step 4: Remove Resource Load Delay (The Biggest Easy Win)

Load delay is the part you can almost fully remove. TTFB is limited by physics and distance. Load delay is only limited by how you build the page. Your goal is simple: the browser should start downloading the LCP image as soon as it reads your HTML.

4a. Put the LCP image in the HTML

If your hero image is a CSS background or is added by JavaScript (sliders, page builders, React apps), the browser cannot see it until CSS or JS has loaded. Use a normal <img> tag in the HTML for your main image whenever you can.

4b. Add fetchpriority=”high”

Browsers start most images at low priority. The fetchpriority attribute tells the browser this image matters most:

<img src="/hero.avif" alt="Main banner" width="1200" height="600" fetchpriority="high">

WordPress benchmarks found this one attribute usually improves LCP by 5 to 10 percent, and since WordPress 6.3 the core software tries to add it to the likely LCP image for you. In one Google test, LCP dropped from 2.6 seconds to 1.9 seconds with this change alone. Use it on one image per page. Priority is shared, so marking five images “high” helps none of them.

4c. Never lazy-load the LCP image

Lazy loading is great for images lower on the page. On your hero image it does real damage, because the browser waits for layout before it loads it. Remove loading="lazy" from the first big image. Check your theme, your optimization plugin and your page builder, since any of them can add it automatically.

4d. Preload images the browser cannot find early

If the LCP image must stay in CSS, preload it in the head:

<link rel="preload" as="image" href="/hero.avif" fetchpriority="high">

Keep critical preloads to a small handful. Preloading ten files slows them all down.

Step 5: Shrink Resource Load Duration

Now make the download itself fast. This is where classic image advice belongs:

  • Use AVIF with a WebP fallback. AVIF usually gives smaller files than WebP and JPEG at similar quality. A <picture> element lets older browsers fall back safely.
  • Serve the right size. A phone does not need a 2,400-pixel-wide image. Use srcset and sizes so mobile users get a smaller file.
  • Serve images from a CDN. An image CDN can resize and convert formats on the fly.
  • Self-host the image. Loading the hero from a different domain adds DNS and connection time. If you must, use preconnect for that domain.
  • Cache images long-term. Returning visitors should get the image from their browser cache.

For an online store, product photos are usually the LCP element. Our guide to ranking Shopify product pages covers more on product image SEO.

Speedometer showing fast largest contentful paint under 2.5 seconds
Photo by clipnjoy on Unsplash

Step 6: Kill Element Render Delay

Sometimes the image has fully downloaded but still does not show. That is render delay. Common causes and fixes:

Cause Fix
Large render-blocking CSS file Inline critical CSS; load the rest without blocking
Render-blocking JavaScript in the head Add defer or move scripts to the end
Client-side rendering (React, Vue apps) Use server-side rendering or static HTML for the first view
A/B testing or “anti-flicker” scripts hiding the page Remove them or run tests on the server
Slow web fonts when LCP is text Self-host fonts, preload the main font, use font-display: swap
Heavy third-party scripts (chat, ads, trackers) Delay them until after load or user interaction

Watch for one trap. When you fix load delay, the time you saved can sometimes turn into render delay instead, because the page still is not ready to paint. That is why you measure all four subparts after every change, not just the total.

Step 7: Use 2026 Extras for Near-Instant LCP

Once the basics are solid, these newer tools can push LCP even lower:

  • Speculation Rules (prerender): Chrome can prerender the next page a user is likely to visit, such as when they hover over a link. When they click, the page is already painted, so LCP is close to zero. WordPress 6.8 added speculative loading to core with safe default settings.
  • 103 Early Hints: some CDNs can tell the browser to start loading critical files while the server is still building the HTML.
  • Back/forward cache (bfcache): pages restored from bfcache load instantly. Avoid things that block it, such as unload event handlers.

Step 8: Re-Test, Monitor and Wait 28 Days

Lab tools show changes right away. Field data in Search Console and PageSpeed Insights uses a rolling 28-day window, so real results take up to four weeks to fully appear. After you validate a fix in Search Console, keep an eye on it.

Speed is also only one part of a healthy site. If pages are fast but still not ranking, check for hidden SEO mistakes, weak internal linking, or whether your site is invisible on Google and AI tools for other reasons.

Person checking Core Web Vitals and LCP results on a laptop
Photo by mjessier on Unsplash

LCP Optimization Checklist for 2026

  • Field LCP checked in PageSpeed Insights and Search Console
  • LCP element identified for each main template
  • Four subparts measured and compared with the budget
  • TTFB at 800 ms or less (cache, CDN, no redirects)
  • LCP image is a normal img tag in the HTML
  • fetchpriority=”high” on one LCP image only
  • No loading=”lazy” on the LCP image
  • AVIF or WebP, correct size with srcset
  • Critical CSS inlined, scripts deferred
  • Third-party scripts delayed
  • Speculation rules enabled where safe
  • Results re-checked after 28 days

FAQ: LCP Optimization Best Practices 2026

What is a good LCP score in 2026?

A good LCP is 2.5 seconds or less, measured at the 75th percentile of real page visits. Between 2.5 and 4 seconds needs improvement, and above 4 seconds is poor.

Why is my LCP bad even after compressing images?

Because image download time is usually a small part of LCP. Google’s data shows slow server response (TTFB) and late image discovery (load delay) cost far more time. Check the LCP breakdown in PageSpeed Insights to see which part is slow.

Should I add fetchpriority=”high” to every above-the-fold image?

No. Use it on the single LCP image only. If many images are marked high priority, they compete with each other and with your CSS, and you lose the benefit.

Why is my mobile LCP worse than desktop?

Mobile phones have slower processors and often slower networks. They also run your JavaScript more slowly, which increases render delay. Serve smaller images to mobile and cut heavy scripts.

How long until Search Console shows my LCP fix?

Field data uses a rolling 28-day window, so expect up to four weeks before the report fully reflects your changes.

Conclusion

The best LCP optimization practice in 2026 is not a secret plugin. It is a method. Measure field data, break LCP into its four subparts, and fix the part that is over budget. For most sites that means a faster server response and letting the browser find the LCP image right away with a real img tag and fetchpriority=”high”. Then shrink the image, remove render blockers and add prerendering. Follow these steps in order and getting under 2.5 seconds becomes a clear, repeatable process instead of guesswork.

Sources: web.dev: Optimize Largest Contentful Paint, web.dev: Common misconceptions about how to optimize LCP, WordPress Core: fetchpriority proposal, Chrome for Developers: Prerender pages.

Muhammad Amjad Butt
Written by

Muhammad Amjad Butt

SEO Trainer, CEO & Founder of PB Outreach

Muhammad Amjad Butt is an SEO specialist from Faisalabad, Pakistan, practicing SEO since 2006. He is the CEO and founder of PB Outreach and the trainer behind Pak SEO Training. He has trained 500+ students and completed 1,000+ guest posting projects for clients.

Resources