How to Improve Google PageSpeed Score in 2026
A fast website gives visitors a smoother browsing experience, helps them access information quickly, and makes it easier to complete actions such as submitting forms or purchasing products. Slow-loading pages, oversized images, unnecessary scripts, and poorly configured hosting can all affect website performance.
Google PageSpeed Insights is a free tool that helps website owners identify performance problems and understand which improvements may have the greatest impact.
Although achieving a score of 100 is possible for some pages, it is not guaranteed for every website. The goal should be to improve real-world loading speed, responsiveness, and visual stability rather than chasing a perfect score at the expense of functionality.
In this guide, you will learn how to test your website, understand PageSpeed metrics, optimize images, reduce unnecessary code, improve caching, and measure the results.
What Is Google PageSpeed Insights?
Google PageSpeed Insights is a free website performance testing tool. It analyzes a page and provides performance metrics, diagnostic information, and suggestions for improvement.
You can test your website using the official tool:
Enter a complete page URL and run the test. If possible, test both your homepage and important landing pages because performance can vary across different parts of the same website.
PageSpeed Insights provides two main types of performance information.
1. Lab data
Lab data is collected under a simulated testing environment using Lighthouse. It helps developers investigate loading behavior and identify potential bottlenecks.
Lab tests are useful when comparing changes, debugging performance problems, and testing a page before or after deployment.
However, results may vary between test runs because of differences in network conditions, testing environments, and other factors.
2. Field data
Field data reflects the experience of real Chrome users, when sufficient data is available. PageSpeed Insights uses the Chrome User Experience Report, also known as CrUX, for this information.
Field data helps you understand how visitors experience your website under different real-world conditions.
A page may not have enough traffic data to show page-level field results. In that situation, origin-level data may be available, or field data may be unavailable altogether.
Important: Lab data and field data measure different things. Use lab testing to diagnose problems and field data to understand actual user experience.
Understanding Google PageSpeed Scores
PageSpeed Insights reports a Lighthouse performance score from 0 to 100.
| Performance score | General interpretation |
|---|---|
| 90 to 100 | Good |
| 50 to 89 | Needs improvement |
| 0 to 49 | Poor |
These categories describe the Lighthouse lab score. They are not a guarantee of real-world performance or search rankings.
The score is calculated from several performance metrics. Improving a metric that has a substantial influence on the score may produce a noticeable improvement, but the effect depends on the page and its current bottlenecks.
Do not focus exclusively on the number at the top of the report. Read the diagnostics to understand what is making the page slow.

The Core Web Vitals You Should Understand
Google’s Core Web Vitals measure important aspects of loading performance, responsiveness, and visual stability.
The current Core Web Vitals are Largest Contentful Paint, Interaction to Next Paint, and Cumulative Layout Shift.
| Metric | What it measures | Good target |
|---|---|---|
| Largest Contentful Paint (LCP) | How quickly the main visible content loads | 2.5 seconds or less |
| Interaction to Next Paint (INP) | How quickly the page responds to user interactions | 200 milliseconds or less |
| Cumulative Layout Shift (CLS) | How much unexpected layout movement occurs | 0.1 or less |
These targets are assessed at the 75th percentile of real-user visits, with mobile and desktop considered separately. https://web.dev/articles/vitals
Largest Contentful Paint
LCP measures when the largest visible content element has rendered. This is often a hero image, large heading, or main content block.
A slow LCP may be caused by a slow server response, a large image, render-blocking resources, or delayed loading of the main content.
Interaction to Next Paint
INP measures how responsive a page feels when users interact with it.
Long-running JavaScript, heavy third-party scripts, and expensive browser tasks can delay visual feedback after a click, tap, or keyboard interaction.
Cumulative Layout Shift
CLS measures unexpected movement of page elements while the page loads or updates.
For example, an image without reserved dimensions may push text downward after it appears. Ads, banners, and dynamically inserted content can also cause layout shifts.
Read Google’s official Core Web Vitals guide for further details.
Step 1: Test Your Website Before Making Changes
Before optimizing anything, establish a baseline.
- Open PageSpeed Insights.
- Enter your website URL.
- Run the mobile test.
- Record the performance score and important diagnostics.
- Run the desktop test.
- Save or record the results for comparison.
Start with pages that matter most to your business, such as the homepage, service pages, product pages, and checkout.
Pay attention to diagnostics such as:
- Largest Contentful Paint element.
- Render-blocking resources.
- Reduce unused JavaScript.
- Reduce unused CSS.
- Properly size images.
- Efficiently encode images.
- Minimize main-thread work.
- Avoid large layout shifts.
- Reduce the impact of third-party code.
Not every recommendation will apply to every website. Fix the problems that are actually affecting your page rather than attempting to eliminate every warning.
Step 2: Optimize Images Without Sacrificing Quality
Images can contribute significantly to page weight, especially on websites that use large banners, product photographs, or featured images.
Compress images
Reduce image file sizes while preserving enough visual quality for the intended display.
Depending on the image, you can use formats such as WebP or AVIF. JPEG and PNG may still be appropriate for certain images or compatibility requirements.
Before uploading an image, consider:
- Whether its dimensions are larger than necessary.
- Whether its format is suitable.
- Whether its compression can be improved.
- Whether the image is actually needed on the page.
A 2,000-pixel-wide image displayed in a 300-pixel container may waste bandwidth if the larger dimensions are not needed.
Serve responsive images
Use responsive image markup so browsers can choose an appropriate image size for the visitor’s screen and layout.
WordPress automatically supports responsive images in many standard image-output situations. Custom themes and manually coded layouts should be checked to ensure they use appropriate image sizes.
Lazy-load below-the-fold images
Images that appear far down a page can often be loaded when they approach the visible area.
However, avoid lazy-loading the main image or other important content that needs to appear immediately. Delaying the LCP image can make perceived loading performance worse.
Reserve image dimensions
Specify image width and height, or otherwise reserve the correct space in the layout. This helps prevent content from jumping when images load.
Recommended approach: Compress images, use appropriate dimensions, and check the results in PageSpeed Insights before adding more optimization tools.
Step 3: Improve Server Response Time
Even well-optimized images and scripts cannot fully compensate for a slow server.
The initial server response affects how quickly the browser can begin processing a page. PageSpeed diagnostics may indicate that server response time is contributing to poor loading performance.
Consider the following improvements:
- Review your hosting plan and available resources.
- Check server CPU, memory, and storage usage.
- Update your application and database software when appropriate.
- Investigate slow database queries.
- Reduce unnecessary plugins and background processes.
- Use a properly configured caching system.
- Consider a CDN when it suits your audience and hosting setup.
For WordPress websites, performance can be affected by the theme, plugins, database activity, and external services, not just the hosting plan.
If server response time remains poor after basic optimization, review hosting logs and performance data before upgrading. Identify whether the bottleneck is server resources, application code, database queries, or network latency.
Step 4: Enable Browser and Page Caching
Caching allows certain content or responses to be reused instead of generated or downloaded from scratch on every visit.
There are several types of caching.
Browser caching
Browser caching allows eligible files, such as images, fonts, stylesheets, and scripts, to be stored locally for reuse.
Configure suitable cache headers for static assets. Versioned filenames or cache-busting techniques can help ensure visitors receive updated files after a change.
Page caching
Page caching stores generated page output so that the server does not have to rebuild the same page for every request.
It can be particularly useful for WordPress sites with mostly static content. Dynamic pages, personalized content, shopping carts, and logged-in areas may need special handling to prevent incorrect content from being cached.
Object caching
Object caching can reduce repeated database work for applications that support it. Its usefulness depends on the site’s architecture, traffic, and database workload.
WordPress caching plugins
WordPress users can evaluate a caching plugin that is compatible with their hosting environment. Some hosting providers already provide server-level caching, so installing multiple overlapping plugins may be unnecessary.
After enabling caching, test the homepage, login, forms, search, shopping cart, and any other dynamic features.
Caching should improve performance without causing outdated content or broken functionality.
Step 5: Minimize Unnecessary CSS and JavaScript
CSS controls the appearance of a page, while JavaScript adds behavior and interactivity. Large or inefficient files can delay rendering and user interactions.
Review your page for:
- Plugins that load scripts on pages where they are not needed.
- Unused CSS and JavaScript.
- Large libraries used for small features.
- Render-blocking stylesheets and scripts.
- Scripts that execute expensive tasks on the main thread.
- Third-party scripts that load slowly.
Minify CSS and JavaScript
Minification removes unnecessary characters, such as comments and extra whitespace, from supported files. It can reduce transfer size, although the benefit varies.
Defer non-critical JavaScript
Some scripts can be deferred or loaded after the initial HTML has been processed. This may help the browser render important content sooner.
Do not blindly defer every script. Some scripts depend on others or must run before a particular interaction works.
Remove unused plugins and scripts
In WordPress, each plugin may add CSS, JavaScript, database queries, or external requests.
Review plugins individually and remove those that are no longer needed. Before deactivating a plugin, confirm that it is not required for forms, security, payments, navigation, or another essential feature.
Test after each significant change so that you can identify which change caused any new problem.
Step 6: Reduce Render-Blocking Resources
Some CSS and JavaScript resources can delay the browser from displaying important content.
Start by reviewing the PageSpeed Insights diagnostics and identifying the resources that are actually blocking rendering.
Possible improvements include:
- Removing unnecessary CSS and JavaScript.
- Loading non-critical scripts later.
- Reducing the size of critical styles.
- Improving the delivery of essential fonts.
- Avoiding excessive stylesheets or script dependencies.
Critical CSS techniques can help a browser render the visible portion of a page sooner, but they require careful implementation. Incorrect configuration may produce missing styles or additional layout changes.
For a WordPress site, use a compatible optimization solution or a developer who understands your theme and plugins. Avoid enabling every performance setting simultaneously without testing.
Step 7: Improve Font Loading
Web fonts can affect both loading performance and visual stability.
To improve font delivery:
- Remove font weights and styles that are not used.
- Avoid loading several unnecessary font families.
- Use appropriately sized font files.
- Consider locally hosting fonts when suitable and legally permitted.
- Preload only fonts that are genuinely critical to the initial display.
- Use a suitable font-display strategy.
- Reserve sufficient space to reduce layout shifts where font changes affect text dimensions.
Preloading too many fonts can compete with more important resources, so prioritize carefully.
After changing font delivery, check that headings, navigation, buttons, and body text display correctly on mobile and desktop.
Step 8: Optimize the Largest Contentful Paint Element
If LCP is poor, first identify which element is being measured.
It might be a hero image, a large heading, a featured image, or another prominent content block.
If the element is an image:
- Serve an appropriately sized image.
- Compress it.
- Ensure the browser can discover it early.
- Avoid lazy-loading it if it is the main above-the-fold image.
- Consider carefully whether preloading it is appropriate.
If LCP is caused by text, investigate server response time, render-blocking CSS, font loading, and other resources that delay rendering.
The correct solution depends on the LCP element and the timing breakdown shown by the testing tools. Avoid applying image-specific fixes when the main problem is a slow server or blocked rendering.
Step 9: Reduce Layout Shifts
Unexpected layout shifts can make a page frustrating to use, especially on mobile devices.
Common causes include images without dimensions, late-loading ads, banners inserted above existing content, and fonts that change text layout.
Try these improvements:
- Reserve space for images and embedded media.
- Allocate space for advertisements and banners when their size is predictable.
- Avoid inserting new content above existing content without reserving space.
- Use stable layouts for navigation and page headers.
- Review font loading behavior.
- Test dynamic components during page load.
Not every layout change is harmful. The concern is unexpected movement that interferes with the user’s experience.
Use the layout shift diagnostics in Lighthouse or browser developer tools to identify the elements responsible.
Step 10: Improve Interactivity and Reduce Main-Thread Work
A page may load quickly but still feel slow when visitors click buttons, open menus, or submit forms.
INP measures responsiveness during real interactions. In lab tests, Total Blocking Time can help identify main-thread problems, although it is not the same as INP.
Potential improvements include:
- Reduce long-running JavaScript tasks.
- Remove unnecessary scripts and libraries.
- Simplify expensive interactive components.
- Break up lengthy tasks where appropriate.
- Avoid doing excessive work during button clicks.
- Reduce unnecessary third-party code.
- Test forms, menus, search, and other interactive features.
If your website uses many tracking, advertising, chat, or analytics scripts, review which are essential and whether they can load more efficiently.
Do not remove necessary functionality simply to improve a lab score. Aim for a balance between performance and the features your visitors need.
Step 11: Review Third-Party Scripts
External scripts may be used for analytics, advertising, chat widgets, maps, video embeds, consent management, or social media integrations.
Although these services can be useful, they may add network requests, JavaScript execution, and other performance costs.
Review your third-party integrations and ask:
- Is this service still necessary?
- Does it load on every page?
- Can it load only when needed?
- Can a heavy embed be replaced with a lighter preview?
- Does it delay the initial page display?
- Is the same function provided by multiple tools?
Use delayed loading or a facade for suitable non-critical embeds when this does not interfere with consent requirements or functionality.
For advertising-supported websites, removing every ad script is not necessarily a practical solution. Instead, evaluate the impact of ad placements, loading behavior, reserved layout space, and unnecessary scripts while maintaining compliance with applicable policies.
Step 12: Use a Content Delivery Network When Appropriate
A content delivery network, or CDN, can serve cached assets from locations closer to visitors. Depending on its configuration, it may also provide other performance and security features.
A CDN can be particularly useful when your audience is spread across multiple regions or when your site serves many static assets.
Before choosing one, consider:
- Where most visitors are located.
- Which resources can be cached.
- How dynamic pages are handled.
- Whether your hosting provider already includes a CDN.
- Whether cache invalidation and configuration are manageable.
- Whether the service adds unnecessary complexity.
A CDN does not automatically fix slow database queries, inefficient JavaScript, oversized images, or a poorly designed page. It is one part of a broader performance strategy.
Step 13: Optimize Your WordPress Website Carefully
WordPress users can often improve performance through a combination of suitable hosting, caching, image optimization, and careful plugin management.
Use this practical process:
- Back up your website before major changes.
- Test the current page using PageSpeed Insights.
- Identify the largest performance bottlenecks.
- Check whether your host provides built-in caching or optimization.
- Compress large images and correct their dimensions.
- Review plugins and remove unnecessary functionality.
- Configure compatible caching and asset optimization.
- Test the website after every significant change.
- Compare the results using the same page and device category.
- Review real-user Core Web Vitals when enough field data is available.
Avoid installing several plugins that all minify files, defer scripts, or manage caching. Overlapping settings can cause conflicts and make problems harder to diagnose.
If your site uses a visual page builder, a complex theme, or multiple third-party integrations, test performance changes on a staging site first.
Step 14: Retest and Measure the Results
After implementing an optimization, run PageSpeed Insights again.
Use the same URL and device category so the comparison is meaningful. Because lab scores can fluctuate, perform more than one test when results are inconsistent.
Record:
- The performance score before and after the change.
- LCP and other available lab metrics.
- Relevant Lighthouse diagnostics.
- Any changes in page appearance or functionality.
- Field data and Core Web Vitals when available.
Do not assume that a higher score means every visitor now has a better experience. Compare the metrics and verify that the website still works correctly.
If a change makes the page worse or breaks functionality, revert it and investigate the cause.
A Practical PageSpeed Optimization Checklist
Use this checklist as a starting point for improving your website.
Testing and diagnosis
- Run PageSpeed Insights on mobile and desktop.
- Test the homepage and important landing pages.
- Record the initial score and key metrics.
- Review the LCP element and major diagnostics.
- Check real-user Core Web Vitals when data is available.
Images and fonts
- Compress large images.
- Use appropriate image dimensions and formats.
- Serve responsive images where applicable.
- Avoid lazy-loading the main LCP image.
- Reserve space for images and embeds.
- Remove unnecessary fonts and weights.
Code and caching
- Enable suitable browser and page caching.
- Remove unnecessary plugins and scripts.
- Minify files when useful and safe.
- Review render-blocking resources.
- Reduce unnecessary JavaScript execution.
- Avoid overlapping optimization plugins.
Hosting and delivery
- Review server response time.
- Check hosting resource usage.
- Evaluate whether a CDN is useful.
- Review third-party scripts and embeds.
- Confirm that HTTPS and caching work correctly.
Final verification
- Retest using the same URL and device category.
- Compare the score and underlying metrics.
- Test forms, navigation, and other interactive features.
- Check the page on mobile and desktop.
- Revert changes that cause problems.
- Continue monitoring performance over time.
Common PageSpeed Optimization Mistakes
Chasing a perfect score
A score of 100 is not required for a good user experience. A site with a slightly lower lab score may still perform well for real users, while a perfect lab score does not guarantee good field data.
Installing too many optimization plugins
Multiple tools may duplicate caching or script optimization, introduce conflicts, and make troubleshooting more difficult. Choose a compatible setup and measure its effect.
Lazy-loading every image
Lazy-loading images that are immediately visible, especially the main LCP image, can delay the content users expect to see first.
Preloading too many resources
Preloading can help the browser prioritize critical resources, but excessive preloading competes for bandwidth and can slow down more important content.
Ignoring mobile performance
Desktop performance may be substantially better than mobile performance because devices, network conditions, and page interactions differ. Test both and pay particular attention to mobile results.
Removing useful functionality for a higher score
Analytics, security features, forms, advertisements, and interactive components may be important to your business. Optimize them thoughtfully rather than removing essential features without considering the consequences.
Making too many changes at once
If you change caching, images, scripts, fonts, and hosting settings simultaneously, it becomes difficult to identify which change helped or caused a problem. Make controlled changes and test after each major step.
Frequently Asked Questions
Can I get a Google PageSpeed score of 100?
Yes, some pages can achieve a score of 100 in Lighthouse testing. However, the result depends on the page, testing environment, resources, and functionality. No optimization method can guarantee a perfect score on every test run or for every user.
What is a good PageSpeed score?
A Lighthouse performance score of 90 or above is generally categorized as good. However, the score is only one measurement. You should also review loading performance, responsiveness, visual stability, and available real-user data.
Does PageSpeed affect SEO?
Page experience and Core Web Vitals are among the factors considered in Google’s broader search systems, but achieving a particular PageSpeed score does not guarantee higher rankings. Relevant, useful content and other aspects of search quality remain important.
Why does my PageSpeed score change between tests?
Results can vary because of testing infrastructure, network conditions, caching state, resource contention, and other factors. Run multiple tests and focus on consistent patterns rather than reacting to a single score.
Why is my mobile score lower than my desktop score?
Mobile testing uses a different simulated environment. Pages may be more demanding on lower-powered devices or slower connections, and mobile layouts can load different resources. Test the mobile version and investigate its specific diagnostics.
Which WordPress plugin is best for PageSpeed optimization?
There is no single best plugin for every WordPress site. The right solution depends on your host, theme, existing caching, and the problems identified by testing. Check your host’s built-in features before adding another optimization plugin.
Does a CDN guarantee a higher PageSpeed score?
No. A CDN can improve the delivery of eligible assets, but it will not automatically resolve all server, database, image, JavaScript, or layout problems. Measure its impact on your actual pages.
Conclusion
Improving Google PageSpeed performance requires identifying the problems that matter most and fixing them systematically.
Start with PageSpeed Insights, optimize images, improve caching, reduce unnecessary code, review server response time, and address the specific issues affecting LCP, INP, and CLS. Retest after each major change and make sure your website remains functional.
A perfect score can be a useful target for some lightweight pages, but it should not become the only objective. The best outcome is a website that loads quickly, responds reliably, remains visually stable, and gives visitors a consistently good experience.
No Comment! Be the first one.