To get a perfect (or near-perfect) PageSpeed Insights score, you need to do four things well: paint your main content fast, keep the layout from shifting, respond to interactions quickly, and stop loading anything that is not essential up front. Everything else — minifying files, deferring scripts, optimizing images — serves those four goals. This guide walks through exactly how to hit a green score (90–100), the specific errors you will run into, the new AI-powered Insights feature, and how page speed connects to SEO, AEO, and GEO.
What PageSpeed Insights actually measures
PageSpeed Insights (PSI) reports two different things, and confusing them is the most common reason people chase the wrong fixes.
- Field Data (real users): Pulled from the Chrome User Experience Report (CrUX), this is how actual Chrome visitors experienced your page over the last 28 days. This is the data Google uses for ranking.
- Lab Data (Lighthouse): A single simulated test run in a controlled environment. This is where the 0–100 performance score comes from. It is a diagnostic estimate, not a real-world measurement.
The 0–100 score is weighted across several lab metrics, with the heaviest weight on Largest Contentful Paint and Total Blocking Time. A score of 90–100 is green, 50–89 is orange, and 0–49 is red. For an authoritative breakdown of the methodology, see Google’s own Lighthouse documentation.
The three Core Web Vitals (and their targets)
Core Web Vitals are the metrics Google treats as a ranking signal. A page only "passes" when at least 75% of real visits meet all three thresholds.
- Largest Contentful Paint (LCP) — how fast the biggest visible element (usually a heading or hero image) renders. Target: 2.5s or less. See web.dev on LCP.
- Cumulative Layout Shift (CLS) — how much the page visually jumps as it loads. Target: 0.1 or less. See web.dev on CLS.
- Interaction to Next Paint (INP) — how quickly the page responds to clicks and taps. INP replaced First Input Delay in March 2024. Target: 200ms or less. See web.dev on INP.
The full reference for all three lives at web.dev/vitals. If you optimize for these, the Lighthouse score tends to follow.
The new AI Insights feature in PageSpeed Insights
The biggest recent change is that Google is moving away from a flat checklist of audits toward AI-assisted "Insights" that explain your performance problems in plain language and prioritize them. Instead of a wall of red items, you increasingly get a narrative: what the slowest element is, what is blocking it, and what to fix first.
This goes further inside Chrome DevTools, where AI assistance powered by Gemini can read a full performance trace and generate specific, tailored recommendations — effectively a performance consultant built into the browser. For non-developers, this is a major step: it turns cryptic metrics into an actionable to-do list. The practical takeaway is that you should still fix the underlying causes below, but the new AI layer makes it far easier to know which cause is hurting you most. Treat the AI suggestions as a prioritized starting point, then verify each fix with a fresh run.
The errors you will actually face (and how to fix them)
1. "Error!" or "NO_LCP" across multiple audits
If you see several audits all reporting Error / Unscored at once, Lighthouse could not finish the run. The usual culprit is something that keeps the page busy forever so it never reaches a "loaded" state — most often an autoplaying, looping background video, an infinite animation, or a hanging request. A continuously streaming video iframe means the network never goes idle, so the audit aborts and every dependent metric errors out. The fix is to load heavy media only after the page settles or on the first user interaction (the "facade" pattern), and to make sure your main heading is not hidden behind a JavaScript reveal animation that a non-scrolling crawler never triggers.
2. Render-blocking CSS and JavaScript
Stylesheets and scripts in the <head> block the first paint. Inline the small amount of CSS needed for above-the-fold content, defer or async the rest, and load non-critical JavaScript at the end of the page. This is one of the largest, most reliable LCP wins.
3. Unused CSS and JavaScript
Most sites ship far more code than any single page uses. Split large bundles, remove dead rules, and defer libraries until they are actually needed. The audit will not penalize you for code that loads after the page is interactive.
4. Minify CSS and JavaScript
Minification strips whitespace and comments to shrink file size. Most build tools do this automatically; if you hand-write assets, run them through a minifier before deploying. Pair this with long cache lifetimes and a CDN.
5. Long main-thread tasks
Large JavaScript tasks freeze the page and wreck INP. Break heavy work into smaller chunks, remove unnecessary third-party scripts, and avoid doing layout-thrashing work during load. Every third-party tag (chat widgets, analytics, embeds) is a tax on this metric.
6. Unoptimized images and layout shift
Serve images in modern formats (WebP/AVIF), size them correctly, lazy-load anything below the fold, and always set explicit width and height so the browser reserves space — this single habit prevents most CLS. Preload your LCP image and your primary web font so they arrive early. Our guide on mobile-first website design covers why this matters even more on phones, where most Core Web Vitals are measured.
A practical path to a green score
- Identify the LCP element and make it paint immediately — never hide it behind a scroll animation.
- Defer everything non-essential — heavy media, third-party scripts, and below-the-fold assets.
- Reserve space for images, ads, and embeds to keep CLS near zero.
- Minify, compress, and cache all static assets behind a CDN.
- Cut third-party bloat — each tag you remove helps Total Blocking Time and INP.
- Re-test on a fresh run, both Mobile and Desktop, after each change.
Performance is rarely a one-time project. A solid build sets the foundation, but new content, plugins, and tracking scripts erode it over time. This is exactly the kind of work we bake into our SEO foundation services and every website we design, and it is a core part of a website redesign.
How speed connects to SEO, AEO, and GEO
A fast page is not just a better experience — it is a visibility multiplier across every channel:
- SEO: Core Web Vitals are a confirmed Google ranking signal, and faster pages get crawled more efficiently and convert better.
- AEO (Answer Engine Optimization): Clean, fast, well-structured pages are easier for answer engines and featured snippets to parse. Speed and clarity go hand in hand — the same structured content that loads fast also answers questions directly.
- GEO (Generative Engine Optimization): AI assistants increasingly favor sites that are technically sound and easy to render. Our explainer on what GEO is and our generative engine optimization service go deeper, and schema markup helps both search engines and AI models understand your pages. If you want to know where you stand, an AI visibility audit is a good starting point.
In short: the technical work that earns a green PageSpeed score is the same foundation that helps you rank in search, appear in Google AI Overviews, and get recommended by AI assistants. Performance, structure, and structured data reinforce each other — which is why we treat them as one system rather than separate checkboxes (see our guide to schema for AI search and SEO).
Frequently asked questions
Can every website get a perfect 100 PageSpeed score?
Not always, and you usually do not need to. A score of 90 or above is green and is an excellent, realistic target. Chasing a literal 100 often means removing useful features for diminishing returns. Focus on passing Core Web Vitals with real users, which is what affects rankings.
What is a good Core Web Vitals score?
LCP of 2.5 seconds or less, CLS of 0.1 or less, and INP of 200 milliseconds or less. A page passes only when at least 75% of real-user visits meet all three thresholds.
What is the new AI feature in PageSpeed Insights?
Google has been rolling out AI-assisted Insights that explain, in plain language, what is slowing your page and what to fix first. In Chrome DevTools, Gemini-powered assistance can analyze a performance trace and suggest specific, prioritized improvements, making the data far easier for non-developers to act on.
Does the PageSpeed score affect SEO?
Indirectly but meaningfully. Google uses Core Web Vitals as a ranking signal, and a fast, stable page improves engagement, conversions, and crawlability. The lab score itself is an estimate, but the real-user metrics behind it do influence search performance.
Why does my page show "Error" or "NO_LCP"?
It usually means Lighthouse could not finish measuring, most often because something keeps the page busy forever (an autoplaying or looping video, an infinite animation, or a hanging request) so it never reaches a loaded state, or because your main content is hidden until JavaScript reveals it. Fix the never-settling resource and make above-the-fold content paint immediately.
Want a website that loads fast and ranks? Speed is built in, not bolted on. Get a free quote and we will build (or fix) a site that scores well and converts — or explore our full services to see how performance fits into the bigger picture.
