Largest Contentful Paint (LCP)
When the main thing finally appears - the loading metric Google grades, and the page-speed work that moves it.
- Term
- Largest Contentful Paint
- Measures
- Time until the largest element renders
- Good
- 2.5 seconds or less (75th percentile)
- Usual culprit
- Heavy hero images, slow server, render-blocking
Forms & parts of speech
Definition in plain terms
Largest Contentful Paint (LCP) is the CORE-WEB-VITALS metric for loading performance: it measures the time from when a page starts loading to when its largest content element — usually the hero image, a large heading, or a prominent block of text — finishes rendering in the viewport. It's a proxy for 'when does the page feel loaded to the user,' because the largest element appearing is roughly when the page looks usable. Google's threshold: good is 2.5 seconds or less (at the 75th percentile of real users), needs-improvement to 4 seconds, poor beyond.
The mechanics
Why the largest element and what slows it: LCP focuses on the largest above-the-fold element because that's what dominates the user's perception of load completion — a page where the hero appears in 2 seconds feels fast even if minor elements trail. The factors that slow LCP, which are the fix list: slow server response (a high TTFB — time to first byte — delays everything downstream, so server performance, caching, and CDN delivery are foundational), render-blocking resources (CSS and JavaScript that must load and execute before the browser can paint — the blocking scripts and stylesheets in the critical path), slow resource load times (the LCP element itself loading slowly — the heavy hero image is the single most common LCP culprit, an uncompressed 4MB original where a 200KB optimized WebP would do, the IMAGE-SEO overlap), and client-side rendering delays (when the LCP element is rendered by JavaScript that runs late — the JAVASCRIPT-SEO render-gap hitting performance). The fixes that actually move it, in rough order of impact: optimize the LCP image (compress, use modern formats, serve responsive sizes, and preload it so the browser fetches it early — usually the biggest single win), improve server response (caching, CDN, faster backend — TTFB is the floor LCP can't beat), eliminate render-blocking resources (defer non-critical JavaScript, inline critical CSS, load the rest async), and prioritize the LCP element (preload, fetchpriority, avoid lazy-loading the hero — lazy-loading the LCP image is a classic self-inflicted wound that delays the very element being measured). The measurement honesty: LCP is a FIELD metric at the 75th percentile (real users, real devices, real networks — the Chrome UX Report data Google uses for ranking), so lab scores on a fast connection can look fine while field LCP is poor on the mid-range phones most users carry — optimize for the field, not the lab. The strategic framing this glossary keeps: Core Web Vitals including LCP are a real but modest ranking signal (a tiebreaker among relevant results, not a magic lever — the same caveat as INP), but LCP's bigger payoff is conversion and bounce (a fast-appearing page keeps users a slow one loses — the load-time abandonment the INSTANT-EXPERIENCE entry exists to fight), so LCP optimization is UX-and-conversion work that doubles as an SEO signal.
When it matters
LCP matters most on content-and-commerce pages where loading speed affects both conversion and rankings — landing pages, product pages, articles, anything with a hero image or large above-the-fold element — and especially on image-heavy sites and slow backends where the metric is most often poor. It matters as a conversion lever first (slow-loading pages bleed users before they see anything) and a ranking tiebreaker second. The discipline is field-data measurement at the 75th percentile (real devices, not lab scores), the fix priority of optimizing-and-preloading the LCP image, improving server response, and eliminating render-blocking resources, never lazy-loading the LCP element, and treating LCP as the UX-and-conversion investment it mostly is with the modest SEO benefit as the bonus.
Synonyms & antonyms
Synonyms
Antonyms
Origin & history
Largest Contentful Paint was introduced by Google as part of the Core Web Vitals in 2020, replacing older, easier-to-game load metrics with one that measures when the main content actually appears to the user; it became a ranking input with the Page Experience update and a conversion lever in its own right, since users abandon pages that render slowly.
Etymology: source.
Usage trends
Search interest for this term over the last five years:
Common questions
- What is Largest Contentful Paint?
- The Core Web Vital for loading performance — the time until the largest content element (usually the hero image or heading) renders in the viewport; good is 2.5 seconds or less at the 75th percentile.
- What slows down LCP?
- Slow server response (high TTFB), render-blocking CSS and JavaScript, slow-loading resources (especially heavy hero images), and client-side rendering delays — with the uncompressed hero image the most common single culprit.
- How do you improve LCP?
- Optimize and preload the LCP image (compress, modern formats, never lazy-load it), improve server response (caching, CDN), and eliminate render-blocking resources — measured on field data at the 75th percentile, not lab scores.
Related tools & calculators
Resources & people to follow
- referenceweb.dev — Largest Contentful Paint (LCP)
- referenceChrome UX Report field-data thresholds
- referenceRGM analysis — optimize and preload the LCP image, fix TTFB, never lazy-load the hero; LCP is conversion work that doubles as SEO
Curated, non-competitor resources verified per term.
Related training
- modulePerformance marketing
Disciplines
Areas of marketing where largest contentful paint (lcp) is a core concern: