Skip to main content

How to Prioritize Page Speed Work on a Large Site: Weights, Templates, and Lazy Loading

/ Article

Most page speed backlogs fail on order, not effort, and a large site needs a system that matches how its pages are actually built.

Facts checked Nov 4, 2026. Lighthouse versions and Chrome data tools change, so check the linked Google docs before you plan a sprint.

On a large site, sort page speed work by how much each metric counts toward the Lighthouse performance score. Fix each problem once in its template, not once per URL. Then use data from real visitors to check that the fix worked.

The usual approach looks different. Someone runs one URL through PageSpeed Insights, gets a red score and 20 suggestions, and the team works down the list in the order the report shows it. A month later the backlog is full of one-off tickets, the mobile score has barely moved, and nobody can say which fix mattered. More effort won't fix that. The order of the work is the problem, the same gap between strategy and execution that stalls most search work.

The system has five steps, in this order:

  1. Rank the work by metric weight.
  2. Group pages by template and fix the shared bottleneck once.
  3. Load third-party scripts only where they are needed, after the main content.
  4. Never lazy-load what sits above the fold. Lazy-load below it and right-size images for phones.
  5. Check responsiveness with field data, because a standard lab test can't measure it.

Two terms first. Lighthouse is Google's open-source tool that loads a page in a controlled test (a lab test) and scores its performance. PageSpeed Insights is Google's web tool that runs Lighthouse and also shows data from real Chrome users (field data) when there is enough of it.

Start with the score weights, not the list of suggestions

The Lighthouse performance score is a weighted average of five metric scores. The weights have been the same since Lighthouse 10, and the current release, Lighthouse 13.6.0, still uses them:

Metric What it measures Weight
Total Blocking Time (TBT) How long the main thread is too busy to respond to input while the page loads 30%
Largest Contentful Paint (LCP) When the biggest image or text block in the first screen appears 25%
Cumulative Layout Shift (CLS) How much the layout jumps around as the page loads 25%
Speed Index (SI) How quickly the visible part of the page fills in 10%
First Contentful Paint (FCP) When the first text or image appears 10%

TBT, LCP, and CLS make up 80% of the score, so that is the order of the backlog. Main-thread work comes first, then the biggest image or text block in the first screen, then layout stability. Speed Index and FCP often move with them.

The suggestions in the report don't score anything on their own. Google's scoring doc says only metrics contribute to the score, and the suggestions help only when they improve a metric. In Lighthouse 13 those suggestions are called insights, and the release notes say there are no changes to the performance scoring.

Weight sets the ceiling, the gap sets the payoff

A heavy metric that already scores well has little left to give. Before you rank anything, put each template's metric values into the Lighthouse scoring calculator and look at how many points each metric is leaving on the table. A 30% metric that is nearly perfect can matter less than a 25% metric that is failing.

Also know where to stop. The scoring curve flattens near the top: taking a score from 99 to 100 needs about the same metric improvement as going from 90 to 94. Aim for the green band (90 to 100), not a perfect 100.

One note on what this score is. These weights rank work toward the Lighthouse performance score, which is a lab test. Google's ranking signal is field Core Web Vitals (LCP, INP, and CLS) measured from real Chrome users, and Google says Core Web Vitals are used by its ranking systems.

Group pages by template, then fix each bottleneck once

A large site is mostly copies of a few templates. Ten thousand articles share one article template, one header, one script bundle, and one hero image component. If the hero image is slow on one article, it is probably slow on all of them.

Google's own report works this way. The Core Web Vitals report in Search Console groups similar pages, and Google assumes those groups "have a common framework" and that poor results share the same underlying causes.

A simple process:

  1. List the templates: article, product or app page, category, landing page, home.
  2. Run Lighthouse on a few representative URLs per template, mobile first.
  3. For each template, write down the weakest heavily weighted metric and the shared cause behind it.
  4. File the fix against the template or the shared component, not the URL.

A naming pattern that may help is [Template] - [Metric] - [Task], for example Article - LCP - Serve a mobile-sized hero image. Anyone scanning the backlog can see what each ticket touches and which metric it should move.

One caution: a shared fix spreads a regression as widely as an improvement. Before you change a shared component, check every template that uses it.

Third-party scripts are often the biggest drag on TBT

Tag managers, chat widgets, form protection scripts, video embeds, and analytics tags all run JavaScript on the main thread. Google's TBT guide says improving it usually means reducing blocking scripts, either by making them less blocking or by loading fewer of them, and it points to reducing the impact of third-party code.

Four rules:

  • Remove what nobody uses. Google's guidance is to remove a third-party script if it doesn't add clear value. Removing unused scripts is often the fastest win.
  • Load each script only where it is needed. A form protection script belongs on the template with the form, not on every article.
  • Load the rest after the main content. Use async or defer, or load on interaction, such as loading a chat widget when someone clicks the chat button.
  • Reserve space for anything that renders late, so a widget appearing doesn't push content around and add layout shift.

A useful tool here is a script-by-template map. Rows are scripts, columns are templates, and each cell says needed, not needed, or load on interaction. It turns a vague "defer third parties" goal into a list of specific changes. In Lighthouse 13, the third parties insight groups the page's third-party requests by provider, and Google's advice there matches this rule: "Reduce and defer loading of third-party code to prioritize your page's content." For the broader picture of script cost and search, see this guide to optimizing JavaScript-heavy websites for search engines.

Lazy loading: what goes above the fold, and what goes below

Lazy loading means the browser waits to download an image until it is about to scroll into view. The common mistake is adding loading="lazy" to every image, including the large hero image at the top. That delays LCP, a 25% metric.

One honest note on the second rule. Lighthouse 13 removed the old "Defer offscreen images" audit because offscreen images are already deprioritized by the browser, so lazy loading them saves bandwidth but is unlikely to move the score. Do it for visitors on mobile data plans, not for points.

Lighthouse 13 flags the opposite mistake in its LCP request discovery insight, which catches a lazy-loaded or hard-to-find LCP image. Oversized images show up under improve image delivery.

Responsiveness (INP) needs real-visitor data

Interaction to Next Paint (INP, how quickly a page visibly responds after a click, tap, or key press) replaced First Input Delay as a Core Web Vital on March 12, 2024.

A standard Lighthouse run loads the page and stops. Nobody clicks anything, so there is no interaction to measure. Google's Web Vitals guide lists INP as not measurable in Lighthouse and suggests TBT as the lab stand-in. Google's TBT guide adds that TBT is "not a substitute for INP in and of itself", and recommends measuring INP in the field.

So the order is:

  1. Use field data to find out whether INP is a problem. Google's advice is to start with field data.
  2. Use real-user monitoring to find the slow interaction. Real-user monitoring (RUM) records performance from your actual visitors, including which element was clicked. Google explains how to find slow interactions in the field, and its open-source web-vitals library is the simplest place to start.
  3. Reproduce it in Chrome DevTools. The Performance panel's live metrics view measures interactions you perform by hand, so you can watch the fix work.

Field data comes from the Chrome UX Report (CrUX, Google's public dataset of real Chrome user experiences), the Search Console Core Web Vitals report, the field section of PageSpeed Insights, or your own RUM.

Confirm with field data, at the 75th percentile

A green lab score is a means, not the goal. The goal is real visitors getting fast pages. The Core Web Vitals thresholds for good are measured at the 75th percentile of page loads, separately for mobile and desktop:

Metric Good Poor
LCP 2.5 seconds or less Over 4 seconds
INP 200 milliseconds or less Over 500 milliseconds
CLS 0.1 or less Over 0.25

Search Central lists the same thresholds, and so does the Search Console report.

Field data lags. Search Console shows each group's numbers over the last 28 days, and its Start Tracking button runs a 28-day validation. Judge a release weeks after it ships, not the next morning. For weekly trends, use CrUX Vis, which replaced the retired CrUX Dashboard.

What changed since 2024

If your page speed playbook dates from 2024, update five things:

  • INP replaced First Input Delay as a Core Web Vital on March 12, 2024.
  • PageSpeed Insights moved to Lighthouse 12 on May 10, 2024, and to Lighthouse 13 on Oct 20, 2025, according to the PageSpeed Insights release notes. Lighthouse 13 replaced many old audits with insights shared with DevTools. Scoring did not change.
  • Mobile TBT got stricter in PageSpeed Insights. On Dec 5, 2024, Google adjusted CPU throttling, which should raise lab TBT for sites on mobile. Don't compare mobile TBT from before and after that date as if nothing changed.
  • The CrUX Dashboard is gone. It was retired after November 2025, and CrUX Vis replaces it.
  • Single-page apps are getting new metrics. On Oct 13, 2026, Chrome began publishing experimental versions of LCP, INP, and CLS that include soft navigations, the in-app page changes that don't reload the browser. Google's stable Core Web Vitals scores remain unchanged for now. Chrome says, "We aim to graduate from experimental in May of 2027, subject to feedback," and once they graduate, Search Console is expected to switch to the new data.

FAQs about page speed prioritization

The system on one page

  1. Weight: rank work by Lighthouse score weight, starting with TBT, then LCP and CLS.
  2. Template: find each template's shared bottleneck and fix it once.
  3. Third parties: map scripts to templates, remove the unused ones, and load the rest after the main content.
  4. Lazy loading: keep the first screen eager, lazy-load below the fold, and right-size images for phones.
  5. Field check: confirm INP and the other Core Web Vitals with real-visitor data at the 75th percentile.

Tools and versions will keep changing, so re-check the linked Google docs before you plan the next sprint. The order of the work should hold.