Community hub
0 subscribers7 pages, 0 posts
Recent from talks
All channels
Be the first to start a discussion here.
Be the first to start a discussion here.
Be the first to start a discussion here.
Be the first to start a discussion here.
Contribute something
Welcome to the community hub built to collect knowledge and have discussions related to Google PageSpeed Tools.
Nothing was collected or created yet.
Google PageSpeed Tools
View on Wikipediafrom Wikipedia
 | This article has multiple issues. Please help improve it or discuss these issues on the talk page. (Learn how and when to remove these messages)
|
Google PageSpeed is a family of tools by Google, Inc.[1] designed to help optimize website performance.[2] It was introduced at a Developer Conference in 2010.[3][4] There are four main components of PageSpeed family tools:
- PageSpeed Module (consisting of mod PageSpeed[5] for the Apache HTTP Server and NGX PageSpeed[6] for the Nginx)[7]
- PageSpeed Insights
- PageSpeed Service
- PageSpeed Chrome DevTools extension. These components aim to identify and automatically correct deviations from Google's Web Performance Best Practices.
PageSpeed Modules
[edit]The PageSpeed Modules are the open-source Apache HTTP Server or Nginx web server modules, which automatically apply chosen filters to pages, associated assets (like stylesheets, JavaScript, and HTML files), as well as to images and website cache requirements. These modules do not require modifications to existing content or workflow,[8] meaning that all internal optimizations and changes to files are made on the server side, and present modified files directly to the user. Each of the 40+ filters corresponds to one of Google's web performance best practices rules.
Since the PageSpeed module is an open-source library, it is frequently updated by numerous developers worldwide. It can be deployed by any individual site, hosting providers, or CDNs.[9]
The installation can be done in two ways: from packages or built from source on the following supported platforms:
Ports
[edit]Other servers that offer a PageSpeed optimization module based on Google's Page Speed SDK:
- Apache Traffic Server - ATS page speed[10]
- Microsoft Internet Information Services - IIS WebSpeed[11]
Filters
[edit]PageSpeed module filters are settings, based on which a web page optimization rule is applied. They can be divided into five main categories:
Speed impact
[edit]The PageSpeed Module showed the most significant impact on decreasing web page loading times, payload size, and number of requests compared to other industry options. According to several researchers, 'mod_pagespeed' can reduce loading times by up to 80%, the number of bytes on a wire can be decreased by 30%, and the number of total requests can drop by over 20%. Since many search engines, including Google, employ a ranking algorithm that is affected by a page's loading speed, these optimizations can impact a website's placement in search results.[12][13] As of February 2015, Google has begun testing “Slow” labels on mobile devices[14] for websites that exceed a certain amount of loading time, prompting developers to examine ways to increase a page's load speed.
Google estimates that for every delay in mobile page load time, the conversion rate drops by 20%.[15]
PageSpeed Insights (PSI)
[edit]PageSpeed Insights (PSI) is a free tool from Google that analyzes the performance of a web page on both mobile and desktop devices. It provides suggestions on how to improve the page's speed and overall user experience.
Data and Metrics
PSI utilizes two main types of data:
- Lab Data: Collected in a controlled environment using Lighthouse to simulate user experience. Useful for debugging performance issues.
- Field Data: Real-world user experience data gathered from the Chrome User Experience Report (CrUX) dataset. This data includes metrics like First Contentful Paint (FCP), Largest Contentful Paint (LCP), Interaction to Next Paint (INP), and Cumulative Layout Shift (CLS).
Real-User Experience Data
PSI leverages CrUX data to provide insights into real user experiences. It reports on various metrics over a 28-day period, including:
- First Contentful Paint (FCP): Time taken for the first content to render on the page.
- Largest Contentful Paint (LCP): Time taken for the main content of the page to render.
- Interaction to Next Paint (INP): Time taken for the page to become interactive after the user interacts with it.
- Cumulative Layout Shift (CLS): Measures the amount of unexpected layout shift a user experiences during page load.
- Time to First Byte (TTFB) (Experimental): Time taken for the browser to receive the first byte of response from the server.
- First Input Delay (FID) (Deprecated): Measures the time it takes for a user interaction to be reflected on the page (no longer recommended by Google).
PSI classifies these metrics into three categories based on Web Vitals thresholds: Good, Needs Improvement, and Poor.
Core Web Vitals
A subset of the field data metrics, Core Web Vitals, are critical for a good user experience. These include LCP, INP, and CLS. PSI analyzes these metrics to determine if a page meets the Core Web Vitals assessment criteria. These are also used as a SEO ranking signal.
Lab Diagnostics
PSI uses Lighthouse to analyze a web page in a simulated environment. It provides scores and recommendations for various categories like Performance, Accessibility, Best Practices, and SEO. The Performance category includes metrics like FCP, LCP, CLS, and Time to Interactive, each with scores and improvement suggestions.
Overall, PSI is a valuable tool for website owners and developers to identify performance bottlenecks and improve the user experience of their web pages.
PageSpeed Chrome Extension
[edit]Pagespeed extension is an extension of Chrome Browser and is a part of Google Chrome Developer Tools. Visitors who use PageSpeed regularly can view all given metrics by PageSpeed Insights directly in a browser and download webpage resources, optimized according to web performance best practices. It has now been deprecated[16] and Google recommends the online version be used instead.
PageSpeed Service
[edit]PageSpeed service was a commercial product, provided by Google Inc. The service was offered free of charge since it was still officially in beta version. Service included all Pagespeed Module optimizations and use of Google servers’ infrastructure.[17] Google announced the deprecation of PageSpeed service on 5 May 2015[18] and turned it off on 3 August 2015.[19]
PageSpeed is now a critical tool for businesses looking to rank their website on search engines organically, given that 47% of users abandon websites that take longer than 2 seconds to load. [20]
See also
[edit]References
[edit]- ^ "About PageSpeed Insights". Google Developers. Retrieved 2022-08-13.
- ^ Ivanovs, Alex (16 April 2014). "PageSpeed Module: Improving Your Websites' Performance". huffingtonpost.com/. The Huffington Post. Retrieved 23 March 2015.
- ^ Kerner, Sean Michael (4 November 2010). "Google Speeds Up the Web with Apache Web Server Module". serverwatch.com/news/. Retrieved 23 March 2015.
- ^ Ram, Ramani (2011-07-29). "Page Speed Service: Web performance, delivered". googlecode.blogspot.com/. Retrieved 17 March 2015.
- ^ "Github". github.com. Google Inc. Retrieved 6 August 2020.
- ^ "Github". github.com. Google Inc. Retrieved 6 August 2020.
- ^ "Apache Incubator". modpagespeed.com/. Google Inc. Retrieved 6 August 2020.
- ^ Edwards, Ben (2014-07-28). "Authoring critical above-the-fold CSS". benedfit.com. Retrieved 23 March 2015.
- ^ "PageSpeed Insights SDK". code.google.com. Google Inc. Retrieved 23 March 2015.
- ^ "ats_pagespeed". iispeed.com/. IISpeed B.V. Archived from the original on 2015-05-25. Retrieved 2015-05-25.
- ^ "IIS WebSpeed". iiswebspeed.com/. IISpeed B.V.
- ^ Enge, Eric (2011-03-06). "Case Study: Impact of Code Cleanup on Site Traffic". searchenginewatch.com/. Search Engine Watch. Retrieved 23 March 2015.
- ^ Kuchler, Margaret (19 May 2011). "The Growing Need For Speed: How Site Performance Increasingly Influences Search Rankings". retailtouchpoints.com/. Retail Touch Points. Retrieved 23 March 2015.
- ^ Barry, Shwartz (2015-02-25). "Google Testing A Red "Slow" Label In The Search Results For Slower Sites". searchengineland.com/. Retrieved 17 March 2015.
- ^ "Mobile Page Load Delay Causes Conversion Loss". Think with Google. Retrieved 2024-05-23.
- ^ "PageSpeed Insights | PageSpeed Insights | Google Developers". Google Developers. Retrieved 2016-09-08.
- ^ Lardinois, Frederic (3 August 2012). "Google Updates PageSpeed Service, Promises To "Turbocharge Your Website"". techcrunch.com. The Tech Crunch. Retrieved 23 March 2015.
- ^ "Google Groups". groups.google.com. Retrieved 7 February 2019.
- ^ "Turndown information for PageSpeed Service - PageSpeed Service". Google Developers. Retrieved 7 February 2019.
- ^ Dentten, Will (Dec 6, 2024). "Google Pagespeed Insights: Why Is It Important". Test Valley Digital.
External links
[edit]
Google PageSpeed Tools
View on Grokipediafrom Grokipedia
Google PageSpeed Tools is a suite of open-source tools and services developed by Google to analyze, measure, and optimize the performance of web pages, with a focus on improving loading speeds, reducing latency, and enhancing user experience across devices.[1] Introduced as part of Google's broader "Make the Web Faster" initiative, these tools help developers and site owners identify bottlenecks and implement best practices for faster, more efficient websites.[2]
The origins of PageSpeed Tools date back to 2009, when Google launched PageSpeed as an initial diagnostic tool to provide developers with specific suggestions for accelerating web page performance.[2] This was followed in 2010 by the release of mod_pagespeed, an Apache HTTP server module that automatically applies optimizations such as resource inlining, image compression, and cache extension to reduce page load times by up to 50% on average.[2] Over the years, the suite has evolved to incorporate modern web standards, including integration with Lighthouse for auditing and the Chrome User Experience Report (CrUX) for real-world field data.[3]
Among the most prominent components is PageSpeed Insights (PSI), a free online tool that evaluates a webpage's performance on both mobile and desktop, generating scores based on lab simulations and aggregated user data from the past 28 days.[3] PSI emphasizes Core Web Vitals—metrics like Largest Contentful Paint (LCP) for loading, Interaction to Next Paint (INP) for interactivity, and Cumulative Layout Shift (CLS) for visual stability—while offering prioritized recommendations to address issues like render-blocking resources or inefficient caching.[3] Complementing this, the PageSpeed Module (now supporting both Apache and Nginx) operates server-side to dynamically rewrite HTML, CSS, JavaScript, and images, minimizing manual intervention.[4]
These tools underscore Google's commitment to web performance as a critical factor in search rankings, user retention, and accessibility, with page speed becoming a mobile ranking signal in the Speed Update of July 2018.[5] By providing both diagnostic insights and automated solutions, PageSpeed Tools enable scalable improvements, benefiting billions of internet users through faster, more reliable online experiences.[1]
This command returns results in JSON format.[35]
The API response is structured as a JSON object containing a
Introduction
History and Development
Google PageSpeed Tools originated with the introduction of PageSpeed in June 2009 as a Firefox add-on to analyze and suggest optimizations for web performance.[6] The initial 2009 release was a Firefox add-on integrated with Firebug for analysis. Subsequent releases included a Chrome extension in 2012 and PageSpeed Online analyzer in 2011, marking Google's early emphasis on web speed as a critical factor in user experience and search rankings.[7][8][9] In late 2010, Google launched mod_pagespeed, an Apache module that automatically applied optimization filters to web content on the server side, reducing latency and bandwidth usage without manual intervention.[10] Building on this, ngx_pagespeed followed in 2013 as the equivalent module for Nginx servers, extending server-side optimizations to a broader range of web infrastructures during its alpha phase. These modules represented a shift toward proactive, automated performance enhancements directly within web servers. PageSpeed Insights emerged in 2012 as a web-based tool, evolving from the earlier PageSpeed Online analyzer introduced in 2011, and focusing on providing actionable insights for both desktop and mobile performance.[11][8] By 2018, integration with Lighthouse began, powering PageSpeed Insights with more comprehensive audits for performance, accessibility, and best practices; this transition was complete by 2020, when older API versions were deprecated and Lighthouse fully underpinned the tool's lab data simulations.[12] Several components faced deprecation around this period, including PageSpeed Service, a hosted optimization proxy shut down in August 2015 after four years of operation, and the original PageSpeed Chrome Extension in 2015, which Google recommended replacing with built-in Chrome DevTools.[13][14][15] The server-side modules saw their last releases in 2020 for mod_pagespeed (version 1.14.36.1) and 2018 for ngx_pagespeed (version 1.13.35.2), after which official development by Google slowed, though they remain documented for use.[10] As of 2025, these modules continue to be supported through third-party integrations, such as LiteSpeed Web Server, which incorporates mod_pagespeed for ongoing optimization capabilities.[16] On October 20, 2025, PageSpeed Insights received an update to Lighthouse 13.0, introducing insight-based audits and experimental field data metrics to align more closely with real-world user experiences, including ties to Core Web Vitals introduced in 2020.[17][18]Purpose and Key Concepts
Google PageSpeed Tools serve as a suite of open-source instruments developed by Google to measure, analyze, and optimize website loading speeds, aiming to enhance user experience by minimizing delays that lead to higher bounce rates and to bolster search engine rankings through improved performance signals.[19][20][21] These tools address the critical need for faster web pages, as slower loading times can result in users abandoning sites prematurely, thereby reducing engagement and retention. By focusing on performance bottlenecks, PageSpeed Tools help developers implement optimizations that align with established web standards, ensuring broader accessibility and compatibility across devices.[20] Central to the framework of PageSpeed Tools is the distinction between lab data, which involves simulated tests in controlled environments to debug issues reproducibly, and field data, derived from real-user metrics captured in live browsing scenarios to reflect actual performance variations.[3][22] Key concepts emphasized include mitigating render-blocking resources, such as external CSS and JavaScript that delay initial rendering; resource optimization techniques like image compression and minification to reduce file sizes; and progressive enhancement, which builds core functionality first before layering advanced features to ensure graceful degradation on slower connections.[23][24][25] These principles promote efficient resource delivery without compromising content integrity, fostering sites that load progressively and prioritize visible elements for quicker perceived speed.[26] The benefits of PageSpeed Tools extend to automating many optimizations, such as through server-side modules that rewrite resources on-the-fly, thereby reducing the need for extensive manual coding while enforcing best practices.[2] This automation not only streamlines development workflows but also ensures consistent adherence to performance guidelines that enhance overall web quality. Over time, the scope of PageSpeed Tools has evolved from primarily static file optimizations, like caching and compression introduced around 2010, to incorporating dynamic user-centric metrics such as Largest Contentful Paint (LCP) for load performance, Interaction to Next Paint (INP) for interactivity, and Cumulative Layout Shift (CLS) for visual stability, reflecting advancements in Core Web Vitals by 2025.[2][27][3][28] As an open-source initiative, PageSpeed Tools encourage community contributions to extend functionality, such as custom filters and libraries, while Google oversees core development to maintain reliability and alignment with evolving web standards.[19][29] This collaborative model has broadened the tools' applicability, allowing developers worldwide to adapt and innovate upon Google's foundational performance strategies.Analysis Tools
PageSpeed Insights
PageSpeed Insights is a free online tool provided by Google for evaluating the performance of web pages on both mobile and desktop devices. Accessible at pagespeed.web.dev, it delivers a performance score ranging from 0 to 100 based on automated audits that simulate user experiences and analyze real-world data.[3][30] To use the tool, developers or site owners enter a valid URL and select the device type for analysis, either mobile or desktop. The tool then runs a Lighthouse-powered audit to generate lab data, which measures metrics in a controlled environment, and incorporates field data from the Chrome User Experience Report (CrUX), reflecting aggregated real-user performance from Chrome browsers over the past 28 days. This dual approach provides both synthetic benchmarks and empirical insights into page speed and usability.[3][17] The resulting report features a prominent performance score, categorized by color: green for 90–100 (good), orange for 50–89 (needs improvement), and red for 0–49 (poor). It includes sections on diagnostics, which highlight issues like "Eliminate render-blocking resources" with estimated savings in load time; opportunities for improvement, offering actionable recommendations such as image optimization; and passed audits, confirming best practices met by the page. These components emphasize Core Web Vitals, including Largest Contentful Paint (LCP) targeting under 2.5 seconds for good performance, Interaction to Next Paint (INP) under 200 milliseconds, and Cumulative Layout Shift (CLS) under 0.1.[3][31][32] As of October 2025, PageSpeed Insights integrates Lighthouse 13.0, which introduces unified performance insight audits and enhancements to CPU throttling simulations for more accurate modeling of mid- and low-tier devices. These updates consolidate previous audits and adjust throttling factors to better reflect diverse hardware conditions, improving the relevance of mobile evaluations.[18][17] Despite its utility, PageSpeed Insights is limited to analyzing individual pages rather than entire sites or performing bulk tests, requiring the API for programmatic or scaled usage. It also relies on CrUX data availability, which may not cover all pages or regions comprehensively.[3][33]PageSpeed Insights API
The PageSpeed Insights API is a RESTful interface that enables developers to programmatically access PageSpeed Insights analyses, automating performance audits for web pages using both lab-based simulations and real-world user data.[3] Version 5, released in November 2018, integrates Lighthouse for controlled testing and the Chrome User Experience Report (CrUX) for field metrics, providing suggestions across categories such as performance, accessibility, best practices, and SEO.[17] It is hosted under Google Cloud APIs and offers a free tier with a quota of 25,000 requests per day and 240 requests per minute, sufficient for most monitoring needs without additional billing.[34] To use the API, developers must obtain an API key from the Google Cloud Console by enabling the PageSpeed Insights API and creating credentials, though the key is optional for low-volume access but recommended to avoid rate limiting.[35] The primary endpoint ishttps://www.googleapis.com/pagespeedonline/v5/runPagespeed, invoked via HTTP GET requests.[36] Key parameters include url (the target webpage, required), strategy (desktop or mobile simulation), category (to filter audits, e.g., performance or accessibility), and locale (for localized scoring and suggestions).[36] For example, a basic audit can be performed using cURL:
curl "https://www.googleapis.com/pagespeedonline/v5/runPagespeed?strategy=desktop&url=https://example.com&key=YOUR_API_KEY"
curl "https://www.googleapis.com/pagespeedonline/v5/runPagespeed?strategy=desktop&url=https://example.com&key=YOUR_API_KEY"
lighthouseResult field with detailed audits, including individual scores (0-100) for metrics like First Contentful Paint and cumulative layout shift, aggregated into category scores.[37] It also includes a loadingExperience section with CrUX field data over the past 28 days, such as 75th percentile values for Core Web Vitals like Largest Contentful Paint, reflecting real-user experiences where available.[37] As of October 2025, the API supports Lighthouse version 13.0, incorporating the latest audit rules and metrics.[17]
Common use cases include integrating audits into CI/CD pipelines for automated pre-deployment checks or bulk monitoring of multiple sites to track performance trends over time.[38] Version 4 of the API was deprecated and shut down in May 2019, with v5 established as the standard; high-volume usage beyond quotas may require quota increases via Google Cloud, though the service remains free without mandatory billing.[39][3]
Error handling is essential for robust integrations, with common HTTP status codes including 400 (Bad Request) for invalid parameters like malformed URLs and 429 (Too Many Requests) when exceeding rate limits or daily quotas.[40] Developers should implement retries with exponential backoff for transient errors and validate inputs to minimize failures.[35]
Server-Side Optimization
PageSpeed Modules
PageSpeed Modules are open-source server-side modules developed by Google to automatically optimize web pages by rewriting HTML, CSS, JavaScript, and images on-the-fly, applying performance best practices to reduce latency and bandwidth usage.[4] These modules integrate directly into web servers, enabling real-time resource optimization without requiring manual intervention or changes to site code. The primary components include mod_pagespeed, released in 2010 for the Apache HTTP Server, and ngx_pagespeed, introduced in 2012 as a port for Nginx.[41][4] Mod_pagespeed functions as an Apache module that intercepts requests and applies transformations, while ngx_pagespeed operates similarly within Nginx's architecture to deliver optimized content. Installation for Apache typically involves downloading pre-built binaries from the official repository and enabling the module using commands like a2enmod pagespeed on Debian-based systems, followed by restarting the server.[42] For Nginx, users often compile the module from source by integrating it during Nginx builds or install pre-built packages from third-party repositories like those provided by GetPageSpeed, then reload the configuration.[43][44] Configuration occurs in Apache's .htaccess or httpd.conf files, or Nginx's nginx.conf, where directives such as "pagespeed on" activate the module, alongside settings for rewrite domains and resource exclusions.[45] Supported platforms encompass Apache 2.2 and later versions, as well as Nginx 1.0 and above. As of 2025, integrations exist with LiteSpeed Web Server (since version 5.2) and OpenLiteSpeed, allowing PageSpeed optimizations within those environments, though OpenLiteSpeed's module is noted for potential maintenance challenges.[16][46] There is no official support for Microsoft IIS or cloud load balancers such as AWS Application Load Balancer.[4] Basic configuration includes enabling the module with "pagespeed on", specifying domains for rewriting via "pagespeed MapRewriteDomain", and managing caches through endpoints like /mod_pagespeed/cache/ for Apache or /ngx_pagespeed/cache/ for Nginx to control output storage and purging.[45] Google maintains active documentation for the modules, but the last official core release occurred in 2020, with earlier significant updates around 2017; community-driven efforts, including Apache Incubator projects and third-party builds from providers like GetPageSpeed, continue to offer updates and compatibility fixes into 2025.[10][47] Testing involves appending query parameters like ?PageSpeedFilters=combine_css to URLs to verify specific optimizations, while debugging uses server logs accessible via /mod_pagespeed/admin/ or /ngx_pagespeed/admin/ for performance metrics and error details.Optimization Filters
Optimization filters in Google PageSpeed Modules are modular rules that automatically rewrite and optimize web resources, such as HTML, CSS, JavaScript, and images, to improve site performance by reducing latency and bandwidth usage. These filters implement best practices identified by Google, with over 40 available options that can be selectively enabled or disabled to suit specific needs. They operate server-side, modifying content in real-time before delivery to the browser, and are particularly effective for static resources.[4][48] Key filters focus on common optimizations to minimize HTTP requests and payload sizes. Thecombine_css filter merges multiple CSS files into a single file, reducing the number of server requests and enabling better browser caching. Similarly, combine_javascript consolidates JavaScript files, which is especially beneficial for sites with numerous scripts. The inline_css filter embeds small CSS blocks directly into the HTML, eliminating separate file fetches for minor stylesheets, while rewrite_css minifies CSS code and rewrites image URLs within it for further compression. For images, rewrite_images compresses and resizes them automatically, often converting to efficient formats like WebP where supported, leading to significant bandwidth savings without quality loss.
Advanced filters target more nuanced improvements in rendering and resource loading. The prioritize_critical_css filter identifies and inlines above-the-fold CSS to accelerate initial page rendering, deferring non-essential styles. Defer_javascript modifies script tags to delay execution until after the page loads, preventing render-blocking behavior and allowing parallel downloads. The canonicalize_javascript_libraries filter detects and removes duplicate JavaScript libraries, replacing them with canonical versions to avoid redundant code execution. Additionally, convert_jpeg_to_webp specifically optimizes JPEG images by converting them to the WebP format, which offers better compression for modern browsers.[49]
Configuration of these filters occurs through directives in the server configuration file, such as Apache's .htaccess or httpd.conf. For example, to enable specific filters, use ModPagespeedEnableFilters combine_css,inline_css,rewrite_images for Apache, or the equivalent pagespeed EnableFilters in Nginx. Filters can be disabled individually with ModPagespeedDisableFilters filter_name or forbidden entirely via ModPagespeedForbidFilters to prevent accidental activation. PageSpeed Modules also provide predefined levels like CoreFilters (encompassing safe, broadly applicable filters such as combine_css and rewrite_images) and OptimizeForBandwidth for more aggressive optimizations, simplifying setup for different environments. Parameters like CssInlineMaxBytes (default 2048 bytes) allow fine-tuning thresholds for inlining.[50]
While these filters enhance performance, they introduce trade-offs, primarily increased server CPU and memory usage due to on-the-fly rewriting. For instance, image optimizations like rewrite_images can be computationally intensive, potentially slowing response times on underpowered servers; the RewriteRandomDropPercentage directive (set between 0-100) mitigates this by probabilistically skipping expensive rewrites. Filters such as extend_cache improve long-term caching but may temporarily increase initial payload sizes if resources are not properly versioned. Monitoring tools like PageSpeed Insights are essential to evaluate net gains and adjust configurations accordingly.[51]
As of 2025, PageSpeed Modules' filters remain compatible with modern web standards, including HTTP/2 multiplexing, which complements their request-reduction strategies by allowing efficient handling of combined resources. No new filters have been added since 2017, but existing ones continue to support contemporary browsers and protocols like WebP and lazy loading. Best practices recommend starting with the CoreFilters level for safety, testing on staging environments, and iteratively enabling advanced filters while monitoring via PageSpeed Insights to ensure compatibility and measure improvements in metrics like Largest Contentful Paint.[4][10]
Performance Impact
Core Web Vitals Integration
Core Web Vitals, introduced by Google in May 2020, represent a set of user-centric performance metrics designed to quantify key aspects of real-world user experience on the web.[52] These include Largest Contentful Paint (LCP), which measures loading performance by tracking the render time of the largest image or text block visible in the viewport; Interaction to Next Paint (INP), which assesses interactivity by evaluating the latency between user input and the browser's next paint; and Cumulative Layout Shift (CLS), which gauges visual stability by measuring unexpected layout shifts during page load.[31] INP replaced the earlier First Input Delay (FID) metric in March 2024 to better capture holistic responsiveness across various interaction types.[31] In PageSpeed Insights (PSI), Core Web Vitals are integrated through audits powered by Lighthouse, which flag failures in these metrics during lab simulations and provide diagnostic details for remediation.[3] Field data integration draws from the Chrome User Experience Report (CrUX), displaying 75th percentile pass rates for LCP, INP, and CLS over a 28-day period to reflect aggregate real-user performance.[3] A page passes the Core Web Vitals assessment in PSI if the 75th percentile values for all three metrics fall within "good" thresholds, helping developers identify pages needing attention based on empirical user data.[3] Google PageSpeed Tools facilitate optimization of Core Web Vitals by applying server-side filters in PageSpeed Modules, such aslazyload_images, which defers offscreen image loading to reduce initial bandwidth and improve LCP and CLS scores.[53] Similarly, filters like defer_iframe delay non-critical iframe rendering until user interaction, minimizing layout shifts and enhancing visual stability for CLS. PSI complements this by offering vitals-specific recommendations in its Lighthouse audits, such as prioritizing critical rendering paths for LCP or reducing main-thread work for INP.[54]
The established thresholds for good performance are LCP ≤ 2.5 seconds, INP ≤ 200 milliseconds, and CLS ≤ 0.1, with "needs improvement" and "poor" categories defined by higher ranges (e.g., LCP 2.5–4 seconds as needs improvement).[3] Since June 2021, poor Core Web Vitals performance has influenced SEO as part of Google's page experience signals, potentially lowering search rankings for non-compliant pages.[31]
As of October 2025, Lighthouse version 13.0 consolidates performance audits into unified insights and removes legacy audits.[18] PSI has expanded to report experimental field metrics like Time to First Byte (TTFB), which measures server response latency and indirectly supports LCP improvements by highlighting backend bottlenecks.[3]
Measurement in PageSpeed Tools contrasts lab simulations in PSI—which use controlled environments via Lighthouse to replicate device and network conditions—with real-user monitoring from CrUX field data, enabling developers to correlate simulated diagnostics with actual user experiences.[3] These tools promote achieving at least 75% pass rates at the 75th percentile for all Core Web Vitals to ensure a good overall user experience, though aiming for 90% or higher in performance scores aligns with top-tier benchmarks.[3] Poor vitals can lead to reduced user engagement, underscoring the value of tool-driven compliance for SEO outcomes.[31]