Guide : Google Lighthouse

TL;DR — Lighthouse is a free Google outil que grades a web page from 0 to 100 on choses comme speed and accessibility. It runs lune page in a slowed-down “lab” — a pretend slow phone on a slow network — so the score is souvent lower que votre site feels. It’s a great to-do liste pour improvements, but a élevé score doesn’t déplacer vous up in Google’s rankings.

Ce que Lighthouse is

Google Lighthouse is a free, open-source outil from the team behind Chrome. Vous point it at une URL, it runs a series of checks on lune page, and it hands vous a report card with scores in four areas: Performances (how fast lune page loads), Accessibility (peut personnes with disabilities utiliser it), Meilleur Practices (general web hygiene), and SEO (basic search-friendliness checks).

Chaque score runs from 0 to 100, with color bands so vous know En un coup d’œil how vous did:

• 0–49 is red — poor
• 50–89 is orange — nécessite improvement
• 90–100 is green — bon

The un chose to comprendre premier

Lighthouse tests votre page sous fake, slowed-down conditions — roughly a mid-tier phone on a slow 4G connection. It fait ce on objectif, so it peut catch problems que réel utilisateurs on slower devices voudrait feel.

That’s pourquoi vous pouvez run Lighthouse on a site que loads instantly on votre fast laptop and encore voir a Performances score of 55. You’re pas seeing ce que vous experience — you’re seeing ce que a budget phone on a mediocre network voudrait experience. Utile information, but pas the même chose.

Lighthouse n’est pas PageSpeed Insights (exactly)

You’ve probably seen Lighthouse sans knowing it. Quand vous run une page via PageSpeed Insights (the web outil at pagespeed.web.dev), the “lab” scores it montre vous are Lighthouse. PageSpeed Insights simplement wraps Lighthouse and adds a second définir of numbers from réel utilisateurs (appelé field données, or the Chrome UX Report). Plus on que distinction in the Avancé version.

The big myth to drop

A perfect Lighthouse score ne fait pas mean top rankings. Lighthouse is a utile outil pour finding choses to fix, but the score itself isn’t ce que Google uses to rank vous. The performances numbers Google en réalité cares à propos de pour ranking come from réel utilisateurs, pas from Lighthouse’s lab. Chasing a 100 is great pour votre visitors — simplement don’t expect it to be a rankings cheat code.

Vouloir the metric weights, pourquoi scores jump autour entre runs, and exactly how Lighthouse relates to Core Web Vitals? Switch to the Avancé tab.

TL;DR — Lighthouse is an open-source, automated outil que audits une page in lab conditions (simulated Slow 4G + 4× CPU throttle) and scores Performances, Accessibility, Meilleur Practices, and SEO — PWA was dropped in Lighthouse 12. The Performances score is a weighted average of five lab metrics: TBT 30%, LCP 25%, CLS 25%, FCP 10%, Speed Index 10%. Bands: 0–49 red, 50–89 orange, 90–100 green. It’s lab données, so it is pas the Core Web Vitals ranking signal, it can’t mesurer INP the façon the field fait (it uses TBT as a proxy), and it varies run-to-run. It powers the lab half of PageSpeed Insights; PSI adds CrUX field données on top. A 100 doesn’t buy rankings.

Ce que Lighthouse en réalité is

Google’s propre one-liner is the cleanest definition: “Lighthouse is an open-source, automated outil to aider vous améliorer the quality of web pages.” The mechanics are simplement as simple — “give Lighthouse une URL to audit, it runs a series of audits contre lune page, and alors it generates a report on how bien lune page performed.”

It scores four categories today: Performances, Accessibility, Meilleur Practices, and SEO. Si you’ve lire older guides que dire five, they’re out of date — the PWA category was supprimé in Lighthouse 12 (autour 2024), suivant Chrome’s mis à jour installability criteria. So si a blog post is encore citing a PWA score, that’s votre tell it predates the current version.

The crucial framing is un word: lab. Lighthouse loads votre page in a controlled, simulated environment, pas from votre réel visitors. Que unique fact explique almost every piece of confusion personnes have à propos de it.

How Lighthouse Fonctionne — the lab conditions

By par défaut Lighthouse uses simulated throttling, and it throttles aggressively. The defaults emulate roughly a mid-tier mobile device on a Slow 4G connection:

• Network: the mobile Slow 4G preset — à propos de 150 ms latency and 1,6 Mbps bas / 750 Kbps up. Google describes ce as emulating “the ~85th percentile mobile connection speed même quand run on beaucoup faster fiber connections.”
• CPU: a constant 4× CPU multiplier, simulating a mid-tier phone’s processor on votre faster desktop hardware.

Ce is by design. Lighthouse isn’t trying to tell vous “ce is how fast votre site is pour everyone.” It’s stress-testing lune page contre a slower-than-average cohort so problems surface que votre fast laptop hides. It’s pourquoi a site que feels instant to vous pouvez score 60 — you’re a high-performance MacBook on fiber; the tester is a budget Android on a so-so network.

Un nuance worth keeping straight: simulated throttling (the par défaut) isn’t the même as DevTools / applied throttling. Simulated throttling models how lune page voudrait have chargé sous ceux conditions fondé on an initial unthrottled observation — Google notes ce approach is “both very fast and deterministic.” DevTools-style throttling en réalité slows bas la requêtes, qui Google dit is “not a sufficient model of a slow connection.” Pour repeatable measurement, the par défaut simulated mode is preferred.

The Performances score — how it’s calculated

The Performances score is “a weighted average of the metric scores.” Ces weights were définir in Lighthouse 10 and remain the current publié table. Lighthouse 13 (rolled out 2026) dit so explicitly: it consolidated a définir of non-scoring performances audits into shared “Insights” aussi utilisé by the DevTools Performances panel, but states là are “no changes to the performance scoring” in que release — the scoring is fondé on the metrics ci-dessous, pas the audit noms, and ceux didn’t déplacer. Five metrics faire up the score:

A few choses to internalize ici:

• TBT carries the la plupart weight (30%). It’s the lab proxy pour responsiveness. Délai de première interaction (FID) is gone, and so are older metrics comme Temps to Interactive and Premier Meaningful Paint — they’ve been retired.
• Speed Index is a Lighthouse metric, pas a Core Web Vital. It encore counts pour 10% of the Lighthouse Performances score même though it isn’t un of Google’s ranking-relevant CWV.
• Chaque metric is scored contre a curve, pas a fixed cutoff. Lighthouse takes the raw valeur (usually in milliseconds) and maps it onto a log-normal distribution construit from real-world HTTP Archive données. Google’s contrôler points: the 25th percentile of que données lands at a score of 50, and the 8th percentile lands at 90. So a 90+ signifie you’re roughly in the top ~8% of pages on que metric — qui is pourquoi the dernier few points are so hard to win.
• Seulement the metric scores déplacer the number. The Opportunities and Diagnostics sections of the report are guidance — ils tell vous ce que to fix — but ils don’t directement modifier the Performances score. Fixing les improves the metrics, and the metrics déplacer the score.

Pourquoi votre score changements entre runs

Ce is the complaint I hear la plupart: “I ran it twice and got 84 alors 91 — is it broken?” No. Google is explicit: “A lot of the variability in votre overall Performances score and metric valeurs n’est pas due to Lighthouse.” Quand the number jumps, it’s usually the underlying conditions shifting:

• A/B tests or différent ads being served on chaque charger
• Internet routing changements — les deux votre local network and the plus long cross-region chemin une requête takes
• The web server itself responding at inconsistent speeds
• Testing on différent hardware (a fast desktop vs. a tired laptop) — CPU throttling is relative to the host machine, so a “4×” multiplier signifie something différent on a fast machine que a slow un
• Navigateur extensions que inject JavaScript or supplémentaire network requêtes
• Antivirus software or autre background processes competing pour resources

Par exemple: run the même URL twice and un réussir se produit to charger a heavier ad creative or catches a slower server réponse — que run’s audits reflect que un charger, pas a defect vous introduced. Treat it as a unique sample, pas a verdict.

The correct mental model, straight from the docs, is to treat performances as a distribution of scores, plutôt que a unique number. Run it a few times — ideally in an incognito window with extensions off, on matched hardware and network conditions — and regarder at the range or median, pas un result. Quand vous devez comparer runs plus tard, remarque the Lighthouse version, run mode, and throttling méthode alongside the score; a score from a différent version or configuration isn’t a like-for-like comparison, même si the number semble similaire.

How to run Lighthouse responsibly

Utiliser Lighthouse as a controlled diagnostic, pas a one-click verdict:

1. Tester the exact deployed URL, pas a différent template or an unpublished local construire.
2. Match the device profile, throttling méthode, Lighthouse version, cache state, authentication, consent state, and tester geography pour every comparison.
3. Commencer chaque run with a fresh navigation. Resizing an already-loaded desktop page into a mobile viewport ne fait pas reproduce a mobile navigation, requête sequence, or server réponse.
4. Run au moins three times. Report the median as the headline result and retain the individual runs, range, timestamps, warnings, and traces so an outlier is visible plutôt que silently discarded.
5. Comparer avant and après sous the même conditions. Si the tester service runs from un autre region, record it: ajouté network distance or a différent CDN edge peut modifier server and chargement timings sans a code modifier.
6. Vérifier CrUX separately avant making a real-user claim. A meilleur lab median supports “this change improved this controlled test,” pas “users now pass Core Web Vitals.”

The evidence supports différent conclusions:

Ce follows Lighthouse’s propre distribution-based model pour score variability and garde the lab/field distinction intact. Evidence for this claim Lighthouse performance scores are weighted from lab metrics; 90–100 is good, 50–89 needs improvement, and 0–49 is poor. Scope: Current published Lighthouse performance-scoring model; metric weights can change by Lighthouse version. Confidence: high · Verified: 2026-07-14 Chrome Developers: Performance scoring

Lighthouse vs. PageSpeed Insights — the distinction que matters

Ces obtenir conflated constantly, so be precise:

• Lighthouse is the engine. It produces lab données — the Performances, Accessibility, Meilleur Practices, and SEO scores.
• PageSpeed Insights is a web UI que runs Lighthouse and adds Chrome UX Report (CrUX) field données — réel Core Web Vitals from anonymized réel utilisateurs, affiché quand there’s suffisant données pour l’URL or origin.

So in PSI you’re looking at two différent datasets side by side. The “field data” section at the top (réel utilisateurs, from CrUX) is separate from the Lighthouse “lab données” section below it — and they frequently disagree. When someone says “my PageSpeed Insights score,” ils almost toujours mean the Lighthouse Performances score, pas the field données.

Lighthouse and Core Web Vitals — how ils relate

Lighthouse measures some Core Web Vitals in the lab: it reports LCP and CLS as lab metrics. But there’s a hard limite:

Lighthouse can’t mesurer INP the façon the field fait. Interaction jusqu’au prochain affichage nécessite réel utilisateur interactions to mesurer — there’s aucun réel utilisateur clicking autour in a lab run. So Lighthouse uses Total Blocking Temps as a lab proxy pour responsiveness. TBT correlates with INP, but a passing TBT fait pas guarantee a passing INP pour réel utilisateurs. They’re connexe, pas the même.

Ce is the heart of the lab-vs-field gap. Field données — from CrUX, surfaced in Search Console and the top of PageSpeed Insights — is ce que reflects réel utilisateurs and ce que feeds Google’s page experience signals. Lighthouse lab données is pour debugging and catching regressions avant vous ship. Google’s propre guidance is to “prioritize field données pour understanding real-world utilisateur experiences” and use “lab données pour debugging, testing fonctionnalités avant deployment.”

Où to run it

Même engine, différent surfaces:

• Chrome DevTools — construit into le navigateur (the Lighthouse panel). Meilleur pour pages behind a login, since vous pouvez audit authenticated pages.
• PageSpeed Insights — the no-install web UI at pagespeed.web.dev; runs Lighthouse and adds CrUX field données.
• CLI — npm install -g lighthouse, alors lighthouse <url>; scriptable.
• Node module — import it programmatically into votre propre tooling and CI.
• Lighthouse CI — the official setup pour catching performances regressions on every deploy. The workflow is collect → assert → upload: collect runs Lighthouse multiple times contre une URL (three runs by par défaut) and takes the median report plutôt que trusting un réussir; assert checks que report contre thresholds vous configurer — définir to warn or error per category or metric; upload stores the report so vous pouvez track trend lines over builds. Treat the thresholds as votre team’s regression policy, pas a field-data verdict or a ranking guarantee — they’re catching “this got worse,” pas certifying “this is fast for users.”
• Chrome extension — exists, but DevTools is the recommended in-browser chemin.

The CLI and Node workflows besoin a local install of Chrome to drive.

The myths worth busting

• “A 100 Lighthouse score = top rankings.” Aucun. The Performances score is lab données; it isn’t a ranking signal. Google’s page experience signals utiliser Core Web Vitals field données (CrUX), and même que is un lightweight signal among nombreux — relevance and content quality dominate. Aim pour a strong score parce que it’s bon pour utilisateurs, pas parce que it’s a rankings lever.
• “Lighthouse = field data / what real users experience.” Aucun. It’s throttled lab conditions worse que la plupart réel utilisateurs voir. Réel utilisateurs have warm caches, bfcache, and varying devices. Lighthouse is a worst-case-ish stress tester, pas an average-user readout.
• “PageSpeed Insights is Lighthouse.” Partly. PSI runs Lighthouse pour the lab section and adds CrUX pour the field section. The field numbers — the ones tied to page experience — are CrUX, pas Lighthouse.
• “The PWA category still counts.” It doesn’t. PWA was supprimé as a scored category in Lighthouse 12.

Bottom line

Lighthouse is un of the la plupart utile free outils in SEO technique and web performances — a fast, repeatable façon to trouver what’s slowing une page bas and to guard contre regressions in CI. Simplement hold it at the correct altitude: it’s a lab diagnostic, pas a verdict on real-user experience and pas a ranking score. Utiliser it to trouver and fix; utiliser field données (CrUX, Core Web Vitals in Search Console) to judge si réel utilisateurs are en réalité having a bon temps.

AI summary

A condensed prendre on the Avancé version:

• Lighthouse = open-source, automated lab auditing outil from the Chrome team. Give it une URL; it audits lune page and scores Performances, Accessibility, Meilleur Practices, SEO. PWA was supprimé in Lighthouse 12 (~2024).
• Lab, pas field. It loads lune page sous simulated throttling — roughly Slow 4G + 4× CPU — by design, to surface ce que slower devices/networks experience. That’s pourquoi a “fast” site peut score low.
• Performances score = weighted average of five lab metrics: TBT 30%, LCP 25%, CLS 25%, FCP 10%, Speed Index 10%. FID and Premier Meaningful Paint are gone.
• Bands: 0–49 red (poor), 50–89 orange (nécessite improvement), 90–100 green (bon). Metric scores are mapped onto a log-normal HTTP Archive curve, so the top points are hardest. Opportunities/Diagnostics guide fixes but don’t directement modifier the score.
• Scores vary run-to-run — ads, A/B tests, extensions, network/server conditions, and machine charger (CPU throttling is relative to the host). Treat it as a distribution, pas un number; run in incognito with extensions off, and record the Lighthouse version and settings vous utilisé.
• Lighthouse CI automates ce: it collects multiple runs (three by par défaut), takes the median, and asserts votre team’s thresholds — a regression-catching policy, pas a field-data verdict.
• Lighthouse ≠ PageSpeed Insights: PSI runs Lighthouse (lab) and adds CrUX field données (réel utilisateurs). Ils souvent disagree.
• Lighthouse measures LCP/CLS in the lab but can’t mesurer INP the façon the field fait — it uses TBT as a proxy. Field données (CrUX) is ce que reflects réel utilisateurs and feeds page experience signals.
• Pas a ranking signal. A 100 doesn’t mean top rankings, and a low lab score doesn’t mean a bad real-user experience. Utiliser Lighthouse to debug; utiliser field données to judge.

Documentation officielle

Primary-source documentation from the Google Chrome team.

• Lighthouse overview — ce que Lighthouse is, the audit categories, and every façon to run it (DevTools, CLI, Node, PageSpeed Insights, extension, Lighthouse CI).
• Lighthouse performances scoring — the metric weights, the 0–49 / 50–89 / 90–100 color bands, and the log-normal scoring curve.
• Lighthouse PWA audits — carries the deprecation notice pour the supprimé PWA category.
• Lighthouse throttling (GitHub) — simulated vs. applied throttling, the Slow 4G preset, and the 4× CPU multiplier.
• Lighthouse changelog (GitHub) — the v12 changements: PWA removal, Premier Meaningful Paint removal, INP elevated.
• Lighthouse scoring calculator — plug in metric valeurs and voir le résultating Performances score; handy pour setting targets.

Lab vs. field (web.dev)

• User-centric performances metrics — pourquoi lab testing “isn’t necessarily reflective of how actual users experience your site.”

Quotes from the source

On-the-record statements from Google’s Lighthouse documentation. Chaque lien is a deep lien que jumps to the quoted passage on the source page.

Ce que Lighthouse is, and how it runs

• “Lighthouse is an open-source, automated tool to help you improve the quality of web pages.” — developer.chrome.com, Lighthouse overview. Jump to quote
• “Give Lighthouse a URL to audit, it runs a series of audits against the page, and then it generates a report on how well the page performed.” — developer.chrome.com, Lighthouse overview. Jump to quote

How the Performances score fonctionne

• “The Performance score is a weighted average of the metric scores.” — developer.chrome.com, Lighthouse performances scoring. Jump to quote
• “Once Lighthouse has gathered the performance metrics (mostly reported in milliseconds), it converts each raw metric value into a metric score from 0 to 100 by looking where the metric value falls on its Lighthouse scoring distribution.” — developer.chrome.com, Lighthouse performances scoring. Jump to quote
• On score bands: “0 to 49 (red): Poor” — with 50–89 orange (nécessite improvement) and 90–100 green (bon). Jump to quote

Pourquoi scores vary

• “A lot of the variability in your overall Performance score and metric values is not due to Lighthouse. When your Performance score fluctuates it’s usually because of changes in underlying conditions.” — developer.chrome.com, Lighthouse performances scoring. Jump to quote

Lab vs. field

• “While testing in the lab is a reasonable proxy for performance, it isn’t necessarily reflective of how actual users experience your site.” — web.dev, User-centric performances metrics. Jump to quote

Getting a trustworthy Lighthouse lire — checklist

Avant vous act on a Lighthouse score, assurez-vous the number signifie something:

• Run it in an incognito window with extensions disabled (extensions inject JS and skew the score).
• Run it multiple times and regarder at the range — treat it as a distribution, pas a unique number.
• Confirmer you’re comparing the même formulaire factor chaque temps (mobile vs. desktop — the throttling differs).
• Know qui dataset you’re reading: lab (Lighthouse) vs. field (CrUX) in PageSpeed Insights. Don’t mix les.
• Pour ranking/page-experience questions, regarder at field données (Core Web Vitals in Search Console / CrUX), pas the Lighthouse lab score.
• Remember Lighthouse can’t mesurer INP the façon the field fait — TBT is a proxy, pas a guarantee.
• Fix from the Opportunities/Diagnostics listes, but vérifier the modifier by watching the metric déplacer (seulement metrics modifier the score).
• Pour repeatable measurement in automation, utiliser Lighthouse CI with budgets plutôt que eyeballing one-off runs.
• Contrôler ce que lune page montre on charger: cookie/consent banners, login state, and cache (cold vs. warm) tout modifier the audits que fire — pick un state and be consistent à propos de it.
• Watch pour non-deterministic content — A/B tests, rotating ads, and autre third-party scripts peut serve a différent payload on every run and swing the score independent of anything vous modifié.
• Let lune page en réalité finish chargement avant triggering the audit (or utiliser a mode que waits pour it) — cutting a run off early misreads lune page.
• Record the Lighthouse version and the run settings (mode, throttling méthode, device) alongside the score — a “same” score from a différent version or config isn’t en réalité comparable.
• Ignore quelconque guide encore scoring a PWA category — that’s supprimé in Lighthouse 12.

Lighthouse Performances score — cheat sheet

The five metrics and leur weights (Lighthouse 10 weighting)

Retired / supprimé: FID, Temps d’interactivité, Premier Meaningful Paint.

Score color bands

Mapped onto a log-normal HTTP Archive curve: ~25th percentile → 50, ~8th percentile → 90. The dernier few points are the hardest to win.

Par défaut lab conditions

• Network: mobile Slow 4G (~150 ms latency, ~1,6 Mbps bas / 750 Kbps up)
• CPU: constant 4× multiplier (mid-tier mobile on desktop hardware)
• Throttling: simulated by par défaut (fast, deterministic), pas DevTools/applied

Lighthouse vs. PageSpeed Insights

Fast facts

• Categories today: Performances, Accessibility, Meilleur Practices, SEO (PWA supprimé in Lighthouse 12).
• It’s pas a ranking signal. A 100 ≠ top rankings.
• It can’t mesurer INP comme the field fait — uses TBT as a proxy.
• Scores vary run-to-run — that’s attendu.

Façons to run Lighthouse (and connexe outils)

• Chrome DevTools — Lighthouse panel — construit into Chrome; meilleur pour auditing pages behind a login.
• PageSpeed Insights (pagespeed.web.dev) — aucun install; runs Lighthouse and adds CrUX field données alongside it.
• Lighthouse CLI — npm install -g lighthouse, alors lighthouse <url>; scriptable, nécessite a local Chrome.
• Lighthouse Node module — drop it into votre propre tooling programmatically.
• Lighthouse CI (@lhci/cli) — run Lighthouse on every deploy, définir budgets, and échouer the construire on regressions. The correct outil pour keeping a score from silently sliding.
• Lighthouse scoring calculator (scorecalc) — plug in metric valeurs to voir le résultating Performances score and définir realistic targets.
• Chrome extension — disponible, but DevTools is the recommended in-browser route.

Pour real-user (field) données to pair with ces lab outils, regarder at the Core Web Vitals report dans la recherche Google Console and the CrUX field section in PageSpeed Insights.

Lighthouse habits que créer faux confidence

• Chasing 100 as the business goal. A perfect lab score n’est pas a ranking boost and peut distract from field Core Web Vitals and réel utilisateur outcomes. Utiliser the report to trouver bottlenecks, alors vérifier que utilisateurs benefited.
• Treating un run as a verdict. Lighthouse is a simulated tester and naturally varies. Run it several times sous the même conditions and regarder pour a consistent pattern plutôt que reacting to un score.
• Appel lab TBT the même chose as field INP. TBT is a utile lab proxy pour main-thread blocking; INP measures réel interactions in the field. A bon TBT is evidence, pas proof, que INP is bon.
• Fixing every audit in listed order. Opportunity estimates overlap, and some audits have little impact on lune page’s réel bottleneck. Commencer with the trace, the largest weighted metrics, and the resources responsible pour les.
• Comparing mobile and desktop scores directement. Leur emulation profiles and scoring distributions differ. Comparer comme with comme.

Lighthouse score changements entre runs

Symptom: The même page moves entre color bands sans a deployment.

Probable causer: Variable server réponse, third-party scripts, shared machine charger, or différent tester settings modifié the synthetic run.

Fix and confirmation: Match l’URL, device profile, throttling, cache state, and tester emplacement; run several tests; alors comparer the median trace and metric timings.

Field Core Web Vitals réussir but Lighthouse is red

Symptom: PSI field données passes pendant que the Lighthouse Performances score is poor.

Probable causer: The two sections mesurer différent populations: CrUX summarizes réel utilisateurs over temps, pendant que Lighthouse runs un simulated page charger.

Fix and confirmation: Treat the field assessment as the utilisateur outcome and utiliser the lab trace to reproduce and diagnose a slow-device scenario. Confirmer quelconque fix in les deux repeated lab runs and the suivant field-data reporting window.

Lighthouse ne peut pas mesurer INP

Symptom: The report montre TBT but aucun lab INP valeur.

Probable causer: INP exige réel interactions à travers une page visit; a navigation-only Lighthouse run has aucun representative interaction history.

Fix and confirmation: Utiliser TBT and the trace to trouver long tasks in the lab, alors mesurer INP with field données or an interaction-focused recording.

An audit persists après the obvious fix

Symptom: Lighthouse encore flags an asset après it was optimized or supprimé.

Probable causer: A mis en cache réponse, un autre template, a third-party copy, or a différent requête in the chain encore triggers the audit.

Fix and confirmation: Tester the exact deployed URL with a cold cache, ouvrir the audit’s affected-resource liste, and map chaque listed requête back to its owner.

Testez vos connaissances: Google Lighthouse

Five rapide questions on Lighthouse données and scoring. Pick an réponse pour chaque, alors vérifier.

Ressources utiles

Official

• Lighthouse overview — the definitive ce que/how/where-to-run.
• Lighthouse performances scoring — weights, bands, and the scoring curve.
• Lighthouse throttling docs (GitHub) — the lab conditions in detail.
• Lighthouse scoring calculator — reverse-engineer the metric targets pour a score.
• User-centric performances metrics — the lab-vs-real-users argument, from Google.

Où Lighthouse fits

• Pair the lab score with field données: the Core Web Vitals report in Google Search Console and the CrUX section of PageSpeed Insights. Lab trouve the problems; field indique vous si réel utilisateurs feel les.

From autour the industry

• Differences entre field données and lab données (web.dev) — Google’s propre breakdown of quand to trust lab vs. field numbers and pourquoi ils diverge.
• Core Web Vitals (web.dev) — the canonical référence on qui CWV metrics Lighthouse peut and can’t mesurer, notamment the INP gap.
• Plus grand affichage de contenu (web.dev) — deep dive on LCP thresholds and pourquoi lab and field readings frequently disagree.
• Lighthouse CI on GitHub — official repo and setup guide pour integrating Lighthouse into automated CI/CD pipelines.
• HTTP Archive Web Almanac — Performances chapter — annual données on real-world Lighthouse scores and Core Web Vitals réussir rates à travers millions of pages; utile pour benchmarking votre scores contre the web at grand.
• web.dev — Mesurer page performances — Google’s recommended starting point pour pairing Lighthouse results with field données outils.

Numbers worth citing

• Performances score weights (Lighthouse 10): TBT 30%, LCP 25%, CLS 25%, FCP 10%, Speed Index 10%. Source
• Score bands: 0–49 red (poor), 50–89 orange (nécessite improvement), 90–100 green (bon). A 90 corresponds to roughly the 8th percentile of HTTP Archive données; a 50 to the 25th percentile. Source
• Par défaut throttling: mobile Slow 4G (~150 ms latency, ~1,6 Mbps bas) plus a 4× CPU multiplier — emulating roughly the ~85th percentile mobile connection. Source
• Categories: four today (Performances, Accessibility, Meilleur Practices, SEO) — PWA supprimé in Lighthouse 12 (~2024). Source

Journal des modifications