Do these 3 things before closing this tab:
1Repair Windows errors before they cause bigger problems2Scan for outdated or missing drivers - takes under a minute3Clear out junk files and repair common Windows errorsA perfect 100 in Google PageSpeed Insights (PSI) is possible on an individual test, but it is not a permanent certificate of speed. PSI combines a repeatable Lighthouse laboratory test with Chrome User Experience Report (CrUX) field data from real visitors. The practical goal is to remove the bottleneck that PSI identifies, verify the change on both mobile and desktop, and then confirm that the 75th-percentile field experience meets Google’s Core Web Vitals targets.
Antihost offers managed WordPress hosting with free migration, one-click staging and a 14-day free trial.
Use this sequence: record a baseline, fix Largest Contentful Paint (LCP), improve Interaction to Next Paint (INP), eliminate Cumulative Layout Shift (CLS), clean up remaining Lighthouse audits, and validate the result in Search Console and the next CrUX data window.
As an Amazon Associate I earn from qualifying purchases.
What a 100 score means—and what it does not
PSI scores performance on a 0–100 scale. Google’s published bands classify 90–100 as good, 50–89 as needing improvement, and below 50 as poor. A score of 100 is therefore the top of the laboratory score scale, not a separate ranking factor or a guarantee that every visitor experiences an instant page.
PSI presents two kinds of evidence:
- Lab data: Lighthouse loads the page in a controlled simulation. It is useful for debugging because the device, network conditions and page state are repeatable enough to compare changes.
- Field data: CrUX summarizes real Chrome visits over a trailing 28-day period. When enough data exists, PSI displays the 75th percentile, meaning at least three quarters of measured visits must meet a threshold for that metric to be considered good.
Lab and field results can disagree. A page can score 100 in a single desktop run while mobile visitors still experience slow loading or delayed interaction. Conversely, a page may have a lower lab score yet pass the real-user assessment. Treat the score as a diagnostic signal, not a promise about every device, country or connection.
#1 Best Overall
For comparable measurements, record the URL, date, mobile or desktop mode, test location, browser and Lighthouse/PSI version, plus any relevant login state, cookie banner or personalization. Third-party scripts, cache state, network quality and the exact page content can all move the score between runs.
Core Web Vitals targets to protect
Google’s current Core Web Vitals are Largest Contentful Paint, Interaction to Next Paint and Cumulative Layout Shift. Search’s field assessment passes only when the relevant 75th-percentile values are in the good range.
| Metric | Good target | What it measures | Typical failure pattern |
|---|---|---|---|
| LCP | Less than 2.5 seconds | How quickly the largest visible content element becomes available | Slow server response, a render-blocking stylesheet, or an oversized hero image |
| INP | Less than 200 milliseconds | Responsiveness from a user interaction to the next visual update | Long JavaScript tasks, excessive event-handler work, or too much code executing before interaction |
| CLS | Less than 0.1 | Unexpected movement of visible content during loading and use | Images, ads, embeds or fonts arriving without reserved space |
Google Search Central states that a good experience should strive for LCP within the first 2.5 seconds, INP below 200 milliseconds and CLS below 0.1. These are field-oriented targets; meeting them does not require a 100 laboratory score, and a 100 lab score does not prove that the targets are met for real users.
Step 1: Build a trustworthy baseline
- Choose a representative URL. Start with an important landing page, article template, product page or application route. A fast homepage does not prove that heavier templates are fast.
- Run both modes. Test mobile first because constrained CPU and network conditions usually expose the largest problems, then run desktop to reveal desktop-only regressions.
- Save the complete result. Record the performance score, LCP, INP and CLS values, opportunities, diagnostics, URL, date, mode and environment. Capture screenshots or export the report if your team needs an audit trail.
- Read field data before lab details. If CrUX data is available, note the 28-day 75th-percentile values and the pass or fail status. This is the evidence about actual visitors.
- Repeat an outlier. Run the same test several times when a result is unexpectedly high or low. Compare medians or a consistent run rather than selecting the best score.
Do not compare an old report with a new one without checking the Lighthouse release. Google’s release notes say that PageSpeed Insights and its API were updated to Lighthouse 13.0 on October 20, 2025. A version change can alter audits, weighting or implementation details, so include the version and test date in every comparison.
Step 2: Improve LCP when loading is the bottleneck
LCP is often the quickest route to a large mobile improvement because it combines server delay, resource discovery and rendering of the largest above-the-fold element. PSI identifies the element chosen as LCP; inspect that element before changing code.
Reduce server response time
- Measure the initial document response and identify slow database queries, expensive server rendering, cold starts and cache misses.
- Use full-page or fragment caching for content that does not need per-request generation.
- Keep origin infrastructure geographically close to the main audience, or place a managed CDN in front of the origin when distance and connection setup dominate the delay.
- Verify that compression, HTTP/2 or HTTP/3 and connection reuse are enabled where the hosting stack supports them.
A hosting or CDN change can improve time to first byte and therefore LCP, but it will not automatically fix a large image, blocking CSS or heavy client-side rendering.
Rank #2
Prioritize the largest visible resource
- Make sure the browser can discover the hero image, headline font or other LCP resource early in the HTML and preload only the resource that is genuinely critical.
- Do not lazy-load the above-the-fold image that becomes LCP; reserve lazy loading for content that starts below the viewport.
- Remove redirect chains and avoid injecting the LCP element only after a large JavaScript bundle runs.
Serve efficient, correctly sized images
- Resize images to the largest display dimensions needed by the layout instead of shipping a multi-megapixel original to a phone.
- Use modern formats supported by your audience and provide responsive width variants through the
srcsetandsizesattributes. - Compress photographs and illustrations while checking that text, faces and sharp edges remain legible.
- Specify
widthandheightattributes so the browser can reserve the image’s box before the file arrives.
Remove render-blocking work
Inline only the small amount of critical CSS needed for the first view, then load the remaining stylesheet without blocking the initial render. Split large CSS bundles, remove selectors that the page never uses, and defer nonessential JavaScript. Confirm that the resulting page still renders correctly without relying on a race between scripts and styles.
Step 3: Improve INP when interaction feels slow
INP is a field metric, so a synthetic test can miss the exact interaction that real visitors perform. Use Lighthouse’s long-task and main-thread diagnostics to find likely causes, then monitor field data after deployment.
Ship and execute less JavaScript
- Remove libraries, polyfills and feature modules that the page does not use.
- Split bundles by route and load an interactive feature only when the user can reach it.
- Defer analytics, chat, personalization and other nonessential scripts until after the initial interaction opportunity.
- Prefer server-rendered or progressively enhanced controls when a full client framework is unnecessary.
Break up long tasks
JavaScript that monopolizes the main thread delays input processing and the visual response. Divide large loops and rendering work into smaller chunks, yield between chunks, and move computation to a Web Worker when it does not need direct access to the document. Avoid scheduling a burst of independent tasks immediately after load; that work competes with the user’s first tap or click.
Make event handlers cheap
- Read layout information once, then batch DOM writes to avoid repeated forced reflows.
- Throttle scroll, resize and pointer handlers, and use passive listeners where cancellation is not required.
- Update only the component that changed instead of re-rendering an entire page.
- Do not perform network calls, JSON processing or expensive validation synchronously in the input handler when the result can be staged.
Test the interactions that matter to the page: opening navigation, typing into search, switching tabs, adding an item, submitting a form or expanding a comment thread. A fast first paint cannot compensate for a button that visibly responds late.
Recommended Free Tools
Step 4: Eliminate CLS and visual jumps
CLS measures unexpected movement, not every animation. A page can look polished yet fail when late content pushes an already-read paragraph downward.
Rank #3
- Used Book in Good Condition
Reserve dimensions for media and embeds
- Set intrinsic dimensions or an aspect-ratio box for every image and video.
- Give advertisements, maps, social posts and other embeds a reserved minimum height before their contents load.
- Use a stable skeleton or placeholder whose dimensions match the final component.
Insert content without pushing existing content
Do not insert a consent notice, promotion, recommendation or error banner above content that is already visible unless the layout has reserved room for it. If a banner must appear, overlay it or allocate its space from the beginning.
Control font-related shifts
Choose fallback fonts with similar metrics, preload only the critical font files, and use appropriate font-display behavior. Check that a late webfont does not change line breaks enough to move headings, buttons or the LCP element.
Step 5: Clear the remaining Lighthouse audits
After the principal Core Web Vitals bottleneck is addressed, work through the remaining opportunities and diagnostics in descending order of likely user impact.
Quick wins for a faster PC:
Fix the driver behind crashes, sound loss and screen glitchesFind Drivers →Repair Windows errors before they cause bigger problemsFix Now →- Unused bytes: Remove dead CSS and JavaScript, narrow bundles to the route and eliminate duplicate dependencies.
- Transfer size: Compress text assets, optimize images and avoid downloading resources that a visitor cannot reach.
- Caching: Apply long-lived, immutable caching to versioned static files and revalidate HTML according to its freshness needs.
- Third-party code: Inventory every tag, identify its business owner, load it only where needed and remove vendors that no longer provide a measurable benefit.
- Accessibility: Correct missing labels, poor contrast, keyboard traps and invalid names; these fixes also make the page usable with assistive technology.
- Best practices and SEO: Resolve HTTPS, security, viewport, metadata and crawlability findings when those categories are part of your publishing objective.
Do not chase an audit blindly. Read the affected URL or selector, determine whether it is part of the critical path, implement one change, and retest. A technically “passing” audit that breaks navigation or checkout is not an improvement.
How to retest without fooling yourself
- Deploy one logical change set and note its commit or release identifier.
- Warm and cold-test deliberately; document which cache state you used.
- Run mobile and desktop PSI tests under the same conditions as the baseline.
- Compare metric values and the identified LCP element, not only the headline score.
- Repeat after a short interval to detect run-to-run noise.
- Watch browser error logs, real-user monitoring and business-critical interactions for regressions.
A score that rises because a page rendered a different state, a third-party script timed out or an experiment was disabled is not a durable win. Keep the baseline report so you can distinguish a real improvement from environmental variation.
Why mobile remains low after desktop reaches 100
Desktop and mobile are separate simulations with different CPU and network constraints. A desktop processor can execute a JavaScript bundle quickly while a mid-range phone spends hundreds of milliseconds parsing and compiling it. Mobile also exposes oversized images, expensive fonts, deep DOM trees and third-party tags that desktop hardware hides.
- Check the mobile LCP element and its request chain first.
- Compare total JavaScript transfer, parse and execution time between modes.
- Test with the page’s real geographic audience in mind; a server close to desktop testers may be far from mobile visitors.
- Inspect whether a responsive layout downloads desktop-sized images or loads hidden components unnecessarily.
Prioritize the mobile field distribution in CrUX rather than trying to make the desktop and mobile laboratory numbers identical.
Outdated Drivers Are Slowing You Down
One free scan finds every outdated or missing driver and matches the right update for your exact hardware.Free scan · exact hardware matchPC Slower Than It Used to Be?
A free scan shows the junk files, broken settings and background clutter dragging Windows down - then fixes them in one click.Free scan · Windows 10 & 11Choosing between performance investments
When several fixes or suppliers are available, compare them using the same decision criteria rather than the promise of a higher PSI number.
| Criterion | Questions to ask |
|---|---|
| Field impact | Will the change improve mobile LCP, INP or CLS for the site’s actual 75th-percentile visitors? |
| Effort versus gain | How much improvement is expected per engineering day, and which metric is currently limiting the assessment? |
| Regression risk | Could caching, script removal or layout changes break personalization, forms, accessibility or revenue-critical flows? |
| Geographic fit | Does the solution perform for the countries, device mix and connection types that make up the audience? |
| Recurring cost and visibility | What ongoing hosting, CDN, monitoring or maintenance cost is required, and will the team see regressions quickly? |
Infrastructure changes are most likely to help server response and LCP. Code splitting, event-handler work and third-party governance are usually needed for INP. Layout contracts, reserved dimensions and font strategy are the direct levers for CLS. A single provider or product rarely solves all three.
Common failure modes and recovery
The score changes dramatically between runs
Check test location, cache state, CPU or network emulation, page personalization and third-party availability. Record several runs and compare the same mode and Lighthouse version. Do not publish a “perfect score” based on the best outlier.
The lab score is 100 but field data fails
Field data reflects visitors that the lab cannot model completely. Segment the audience by device and geography, inspect slow templates and third-party code, and wait for the trailing 28-day CrUX window to incorporate the deployment. Validate in Search Console’s Core Web Vitals report rather than relying on one PSI run.
LCP improved but INP became worse
A preload or rendering change may have moved JavaScript earlier in the critical path. Check main-thread tasks and interaction traces, then defer or split the new work. Optimize metrics together instead of trading a faster first element for a slower first interaction.
CLS appears only after ads or consent load
Reserve the final component’s dimensions from the initial layout. If an ad’s size varies, define a bounded slot and choose a fallback that does not collapse the space. Place consent UI in an allocated region or as an overlay rather than inserting it above existing content.
Removing a script breaks a feature
Restore the smallest safe version, scope it to the routes that need it, and load it after the critical interaction path. Add a functional test and monitor errors before attempting further reduction.
When to stop chasing 100
Once the relevant 75th-percentile Core Web Vitals are good and the remaining audits have little user impact, further laboratory points may cost more than they are worth. A page that scores 92 with reliable mobile field performance can be a better product than a fragile 100 that depends on disabled analytics, missing personalization or an unrealistic test state. Set a performance budget for LCP, INP, CLS, transfer size and JavaScript execution, then enforce it in continuous testing so future releases do not silently undo the work.
Free tools Windows power users keep installed
One-click scans. No signup required.
Review PSI after major template, content, hosting, browser or third-party changes. Keep the date and Lighthouse version with every report; the release to Lighthouse 13.0 on October 20, 2025 is a reminder that score comparisons across versions need context.
Quick Recap
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
