Page performance
Page performance, measured in the lab render
Seven rules measured in the rendered page: LCP over 2,500 ms, CLS over 0.1, main-thread blocking above 200 ms or an oversized DOM, page weight above 2 MiB, head parser-blocking scripts, text of at least 1 KiB that arrived uncompressed, and broken images. Each warning is a risk signal, and an absent measurement stays na.
Last reviewed 2026-11-18
The free page scan measures one URL; scheduled audits and the monitoring suite are plan features — see pricing.
What we measure
Seven rules cover how a page performs after the HTML arrives: three for runtime experience (LCP, CLS and main-thread cost) and four for resource delivery (page weight, blocking scripts, compression and broken images). Each is a warning-level signal from the local render lane, and each keeps its own evidence instead of a composite score.
The table states what each signal can and cannot tell you. Two boundaries matter before any number is read: the values are lab measurements, and a missing measurement stays na.
| Signal | What we measure | What it cannot tell you |
|---|---|---|
| Largest contentful paint (lab) | When the largest image or text block in the first viewport painted, plus the element summary and its resource URL, with FCP and TTFB as reference. | Real-user LCP or a CrUX distribution: one lab render on a different network and device. |
| Cumulative layout shift (lab) | The shift score across the load and the first five sources that moved. | Field CLS, or shifts caused by a later interaction rather than the load. |
| Main thread and DOM size | Total blocking time, long-task count, longest task, DOM element count and maximum depth. | INP or real interaction latency: the headless browser has no visitor input. |
| Page weight | Compressed transfer bytes across document, script, stylesheet, image, font, media and fetch responses. | Cache hits, service-worker responses, or bytes the render never requested. |
| Render-blocking scripts | Classic head scripts with a src, without async or defer and not type=module; head stylesheets are counted as reference. | Whether one deferred script still delays a particular browser's first paint. |
| Uncompressed text | Same-origin 2xx text, CSS, JavaScript, JSON and SVG responses of at least 1 KiB with no content-encoding. | Compression a CDN negotiates later, or a resource the page never fetched. |
| Broken images | Sampled images whose response is 4xx/5xx, or whose element is complete with naturalWidth 0 after a decode failure. | Images added after load, CSS backgrounds, canvas output, inline SVG or iframe content. |
The full rule reference — criteria, failure examples and fix steps for every audit check — is in the check reference.
Runtime experience: three rules
These rules answer why the page feels slow once it loads: what painted last, what moved, and how much work the main thread and the DOM carry. The Core Web Vitals explainer gives each rule a failure example and a three-step fix.
Largest contentful paint
Checks: The largest image or text block in the first viewport: paint time, element summary and resource URL, with FCP and TTFB as reference. The rule reads the lab LCP entry after the page stabilises.
Warns when: LCP is over 2,500 ms.
Fix: Compress and preload the named hero resource, remove head scripts that block the first paint, and shorten the server response.
Cumulative layout shift
Checks: The load-time shift score and the first five elements that moved. A score of exactly 0 is a measured pass, not a missing signal.
Warns when: CLS is over 0.1.
Fix: Reserve width and height or aspect-ratio on images and embeds, do not inject content above what is already painted, and animate with transform.
Main thread and DOM size
Checks: Long-task count, total blocking time and longest task, plus the rendered DOM element count and maximum depth.
Warns when: Total blocking time is over 200 ms, the DOM holds more than 1,500 elements, or the tree is deeper than 32 levels.
Fix: Split and defer non-critical JavaScript, remove work from the critical path, and virtualise long lists so the DOM stays under the size limits.
Resource delivery: four rules
These rules answer what the page shipped to get here: total bytes, scripts that hold up the parser, text that arrived uncompressed and images that never loaded. The page weight explainer and image performance explainer cover the fixes in detail.
The resource report also inventories third-party hosts and media bytes. Those figures are context for a fix, not a separate failure: only the four thresholds above warn.
Page weight
Checks: Compressed transfer bytes across every response the render requested, grouped by type. Third-party hosts and media bytes are listed for reference but do not trigger this rule on their own.
Warns when: Total transfer is over 2 MiB (2,097,152 bytes).
Fix: Compress and resize the heaviest assets, split media below the fold, and remove third-party requests the page does not need.
Render-blocking scripts
Checks: Classic scripts in the document head with a src, no async or defer and no type=module, plus the head stylesheet count as reference.
Warns when: At least one head parser-blocking classic script is present.
Fix: Add defer or async where order allows, move non-critical scripts out of the head, and bundle small synchronous scripts into one deferred file.
Uncompressed text
Checks: Same-origin 2xx HTML, CSS, JavaScript, JSON and SVG responses: at least 1 KiB and no content-encoding header.
Warns when: Any of those text resources reaches 1 KiB or more without compression.
Fix: Enable gzip or Brotli at the origin or edge for text responses, and confirm the content-encoding header survives the CDN.
Broken images
Checks: Sampled document images: a 4xx/5xx response, or an element that finished complete with naturalWidth 0 after a decode failure.
Warns when: At least one sampled image is broken. The rule tolerates none.
Fix: Fix the src or the auth rule behind it, replace undecodable files, and re-run the audit to confirm every sampled image loads.
When the checks run
All seven rules depend on a real render. The lane loads the page in headless Chrome, records paint, layout, long-task and resource timing, then judges that sample. Outside the lane there is nothing to judge, so the rules say so instead of guessing.
- Local render lane: the rules run and return pass or warn.
- Static crawl or Browser Run: the local lane is off, so all seven record na with an insufficient signal reason.
- Lane disabled: the same result — na, never pass.
- Single-page re-crawl (M2) and MCP verifyPage: always na; they do not run the performance or resource measurements.
What these checks do not claim
The boundary is part of the feature, not a gap that later copy will quietly fill.
- Lab-only measurement. Every number comes from one local render, not from CrUX, PageSpeed Insights or Search Console field data.
- No INP and no interaction measurement. The headless browser has no visitor input; long tasks and total blocking time are a main-thread proxy, not interaction latency.
- No Lighthouse score and no Core Web Vitals pass. The audit keeps one warning per rule instead of a composite grade.
- The render environment is Linux headless at a fixed viewport. Network, CPU and device differ from a visitor's, so a warning is a direction, not the score a specific user sees.
- A warning is not a ranking factor. The thresholds are community practice, not a Google ranking system.
- An absent measurement is na (insufficient_signal), never pass. Single-page re-crawls and MCP verifyPage always report na.
- No automatic fix. The rules name the risk and the fix direction; the page still has to be changed.
Frequently asked questions
How the checks run
When do these checks run?
Only when the audit runs in the local render lane. Static-HTML crawls, Browser Run audits and runs with the lane disabled record na with an insufficient signal reason for all seven rules — an absent measurement is never reported as pass. Single-page re-crawls and the MCP verifyPage tool are always na.
Is this field data from CrUX or PageSpeed Insights?
No. Every number comes from one lab render of the page, not from CrUX, PageSpeed Insights or Search Console field data. Treat it as a snapshot of what this environment observed, not as the distribution your visitors experience.
Is a warning a ranking penalty?
No. Every rule here is a warning-level signal measured against community thresholds, not a ranking factor in Google's systems. The audit does not turn the rules into a Lighthouse score or declare Core Web Vitals passed.
Fixing what it finds
How do I fix a slow LCP?
Start with the element and URL named in the finding: compress and preload the hero image, remove head scripts that block the first paint, and check server response time. The Core Web Vitals explainer walks through the same three directions.
How do I fix a layout shift?
Reserve space with width and height attributes or aspect-ratio on images and embeds, avoid injecting content above existing content after load, and animate with transform rather than layout properties. A CLS of exactly 0 passes; only a score above 0.1 warns.
Why does a broken image warn when it looks fine to me?
The audit judges the responses the headless browser received. A 4xx/5xx status or a decoded element with naturalWidth 0 is a broken image even when a CDN or a different device would have served it — fix the URL, the auth rule or the file rather than the markup.
Measure the rendered page
Run the page scan, then read the runtime and delivery rules
Seven warning-level rules, measured in the local render lane.