What event ends the First Contentful Paint timer?

The browser draws the first text, image, SVG, or non-white canvas content

Every network request completes

The largest visible element finishes rendering

The page becomes fully interactive

Which statement about FCP and rankings is correct?

FCP is a diagnostic metric, not a Core Web Vital

FCP is one of the three Core Web Vitals

FCP is the only Lighthouse metric Google ranks on

A page has a slow TTFB and a slow FCP. Where should the investigation begin?

Server response, caching, redirects, and connection setup

Why should you inspect a filmstrip alongside FCP?

To verify the first painted content is meaningful to the visitor

To convert field data into lab data

To make Lighthouse use a faster network

To calculate Cumulative Layout Shift manually

Premier affichage de contenu (FCP)

TL;DR — Premier affichage de contenu (FCP) is the moment a visitor sees the premier bit of votre page — quelconque text, image, or graphic — au lieu de a blank white screen. Faster is meilleur; sous 1,8 seconds is the “good” mark. It’s a utile speed vérifier, but it is pas un of the metrics Google uses pour ranking.

Ce que FCP en réalité is

Quand someone clicks a lien to votre page, there’s a short stretch où they’re staring at nothing — a blank screen — pendant que le navigateur récupère and processes votre page. Premier affichage de contenu is the instant que blank screen turns into something réel: a headline, a logo, a photo, anything the visitor peut en réalité voir.

That’s the whole idea. FCP réponses un simple question: “How long jusqu’à the utilisateur sees lune page is alive and doing something?” Une page que paints content in half a second feels fast. Une page que sits blank pour three seconds feels broken — and personnes leave.

Ce que counts as “content”

FCP fires quand le navigateur draws quelconque of ces onto the screen:

Text (a heading, a paragraph, a nav lien)
Images, notamment background images
<svg> graphics
A non-white <canvas> element

A plain background color by itself fait pas count — that’s a différent, précédent chose appelé Premier Paint. FCP seulement counts quand réel content montre up.

What’s a bon score?

Google’s bands, mesuré à travers réel visitors:

FCP temps	Rating
1,8 seconds or moins	Bon
1,8 – 3,0 seconds	Nécessite improvement
Over 3,0 seconds	Poor

You’ll voir votre FCP in outils comme PageSpeed Insights and Lighthouse — the même reports que montrer votre Core Web Vitals.

Fait FCP affecter my Google rankings?

Aucun — pas directement. Ce is the partie la plupart personnes obtenir incorrect. The metrics Google en réalité uses pour ranking are the three Core Web Vitals: LCP, INP, and CLS. FCP isn’t un of les.

But here’s pourquoi it’s encore worth watching: the choses que faire FCP slow — a sluggish server, big stylesheets and scripts que block lune page from drawing — are souvent the même choses que hurt Plus grand affichage de contenu (LCP), qui is a ranking signal. So fixing FCP’s root causes frequently helps LCP aussi — but it’s pas a guarantee, since LCP has causes of its propre (the size and charger priority of its spécifique largest element). Think of FCP as the smoke alarm: worth checking, but pas proof the fire’s out.

The rapide fixes

Si votre FCP is slow, the usual suspects (and Que faire):

Render-blocking fichiers. CSS and JavaScript in votre page’s <head> peut arrêter the navigateur from drawing anything jusqu’à ils finish chargement. Ce is the #1 causer.
A slow server. Si votre serveur takes a long temps to respond (élevé Temps to Premier Byte), le navigateur can’t paint jusqu’à the bytes arrive.
Fonts que hide votre text. Some font setups leave text invisible pour up to three seconds pendant que a web font loads. Switching the rule to font-display: swap montre fallback text immédiatement.

Vouloir the technical version — the lab-vs-field gap, the FCP/LCP diagnostic chain, and the complet fix liste? Switch to the Avancé tab.

TL;DR — FCP is the temps from navigation commencer to quand quelconque page content (text, image, <svg>, or non-white <canvas>) premier renders. It is pas a Core Web Vital — it’s a supplementary, lab-and-field diagnostic metric, and a building block of LCP (FCP se produit at or avant LCP). Field thresholds (p75): Bon ≤ 1,8 s, needs-improvement ≤ 3,0 s, poor > 3,0 s. In Lighthouse 10 it’s 10% of the Performances score. Parce que FCP’s clock starts at navigation — it inclut redirection temps, connection setup, and TTFB — lab (Lighthouse) and field (CrUX) numbers souvent diverge. Fix it où it lives: render-blocking CSS/JS premier, alors TTFB, alors fonts.

Ce que FCP measures (precisely)

Google’s definition, from Philip Walton’s web.dev article, is the accuracy spine ici: “Premier affichage de contenu (FCP) measures the temps from quand the utilisateur premier navigated to lune page to quand quelconque partie of lune page’s content is rendered on the screen.” “Content,” per the même doc, signifie “text, images (notamment background images), <svg> elements, or non-white <canvas> elements.”

The word que fait tout the fonctionner is quelconque. FCP doesn’t care ce que renders — a 40-pixel logo counts the même as a complet hero image. It’s the “is anything on screen yet?” signal, qui is exactly pourquoi it’s an early indicator plutôt que a completion metric.

Un detail that’s facile to miss and changements how vous lire the number: FCP’s clock starts at navigation, so it bundles in everything que se produit avant votre HTML is même parsed. Google’s propre Clé Point: “FCP inclut quelconque unload temps from the previous page, connection définir up temps, redirection temps, and Temps To Premier Byte (TTFB) qui peut be significant quand mesuré in the field.” A server que takes 1,5 s to respond has déjà burned la plupart of votre 1,8 s budget avant le navigateur has processed a unique byte.

FCP n’est pas a Core Web Vital

Let me be blunt à propos de ce parce que la plupart pages hedge it: FCP n’est pas a Core Web Vital and n’est pas partie of Google’s ranking signals. The Core Web Vitals are LCP, INP, and CLS — and FCP isn’t mentioned anywhere on Google’s Search ranking Core Web Vitals page.

Ce que FCP is, in Google’s taxonomy, is an “Other Web Vital” — a supplementary metric that’s utile pour diagnosis. web.dev puts it ce façon: “the metrics Temps to Premier Byte (TTFB) and Premier affichage de contenu (FCP) are les deux vital aspects of the chargement experience, and are les deux utile in diagnosing problèmes with LCP (slow server réponse times or ressources qui bloquent le rendu, respectively).”

So the honest framing pour stakeholders is two-sided, and vous devez state les deux halves sans flinching:

FCP ne fait pas affecter rankings directement. Don’t optimize FCP “for SEO.”
FCP is a great diagnostic pour LCP, qui fait affecter rankings. Render-blocking resources montrer up in FCP premier.

FCP vs Premier Paint (FP)

Ces obtenir conflated constantly:

Premier Paint (FP) fires quand le navigateur paints anything at tout — notamment a bare background color with aucun réel content.
FCP fires seulement quand eligible content renders: text, images (notamment background images), <svg> elements, or non-white <canvas> elements. That’s a spécifique, spec-defined liste — pas a loose “any DOM content” rule — and it’s worth keeping precise, since a background image counts même though it isn’t text in the DOM.

So FP ≤ FCP, toujours. On la plupart pages they’re nearly identical, parce que painting a background color with aucun content on top is rare. Quand là is a meaningful gap, it usually signifie a cosmetic background painted avant quelconque contenu réel did. The Paint Timing API renvoie les deux first-paint and first-contentful-paint entries — but FCP is the un worth analyzing; FP rarely indique vous anything actionable.

FCP vs LCP

The autre pair personnes merge:

FCP = quand quelconque content paints. Fires early. Pourrait be a tiny logo or a nav lien.
LCP = quand the largest element in the viewport renders. Fires at or après FCP.

Google’s wording: FCP measures quand quelconque content is painted and LCP quand the principal content is painted, so LCP is intended to be plus selective. Lire que as “plus selective,” not “certified correct” — neither metric proves lune page’s réel principal content is complet or utile to the visitor. FCP simplement confirms something eligible painted; LCP confirms the largest eligible candidate did. Une page peut have a fast FCP (logo at 0,5 s) and a slow LCP (hero image at 4 s) — que gap is itself a utile diagnostic. And si votre FCP is fermer to votre LCP, that’s souvent a bon sign: it signifie the premier chose painted is aussi the largest un, with aucun wasted early-paint on chrome que doesn’t matter to the utilisateur.

Un measurement oddity worth knowing: parce que of security restrictions on cross-origin image timing, le navigateur API peut in rare cas report LCP précédent que FCP. That’s a measurement artifact, pas something que physically happened.

Thresholds — and pourquoi lab and field disagree

Field thresholds (CrUX, p75): Bon ≤ 1,8 s · nécessite improvement ≤ 3,0 s · poor > 3,0 s. Google’s guidance is to mesurer at the 75th percentile of page loads, split à travers mobile and desktop.

But Lighthouse desktop uses différent, stricter cutoffs — green is roughly 0–0,9 s, orange 0,9–1,6 s, red over 1,6 s — parce que the lab runs a clean, throttled Chrome on a simulated device, pas real-world conditions. (Ceux bands, comme the score weights ci-dessous, are Lighthouse-version-specific — ce reflects the current audit doc as of ce writing.) The Lighthouse FCP score is “a comparison of votre page’s FCP temps and FCP times pour réel websites, fondé on données from the HTTP Archive.”

Ce is the unique la plupart courant source of FCP confusion, so internalize it:

The 1,8 s “good” line is the field (CrUX p75) threshold. Lighthouse desktop’s “green” line is ~0,9 s. Ils are différent scales pour différent jobs.

Field and lab numbers diverge mainly parce que ils sample différent populations, pas parce que un is universally “more true.” Lighthouse runs a unique clean session on fixed device/network conditions. Field/CrUX aggregates réel devices, réel networks, cache states, and navigation types — notamment back/forward-cache restores and prerendered pages, qui don’t automatically obtenir a fresh FCP the façon a normal navigation fait; ils besoin leur propre lifecycle handling (the web-vitals library fait ce pour vous). On la plupart sites the field number fait lire plus élevé — réel utilisateurs carry chaîne de redirectionss, previous- page unload temps, and cold connections a lab run skips — but that’s a tendency, pas a rule. Avant reading a lab/field gap as a problem, vérifier you’re comparing like-for-like (même device class, même network conditions). Utiliser field données pour votre real-world number and Lighthouse pour diagnosis.

Où FCP sits in the Lighthouse score

In Lighthouse 10 — the current version as of ce writing, pas a permanent figure — FCP is 10% of the Performances score. The complet weighting:

Metric	Weight
Total Blocking Temps (TBT)	30%
Plus grand affichage de contenu (LCP)	25%
Décalage cumulatif de mise en page (CLS)	25%
Premier affichage de contenu (FCP)	10%
Speed Index	10%

The Performances score is a weighted average of the individual metric scores, and Google notes the weightings modifier over temps as leur research evolves — FCP has held at 10% from Lighthouse 8 via 10, but confirmer contre whatever version you’re running avant treating “10%” as timeless. The practical lire: a perfect FCP peut seulement déplacer votre Lighthouse number so far — and a bad FCP souvent points at a bad LCP aussi (ils share root causes), though that’s an overlap worth checking, pas something the score guarantees.

Ce que causes a slow FCP

In rough priority order:

Ressources qui bloquent le rendu — the #1 killer. CSS and synchronous JS in <head> force le navigateur to wait: it can’t construire the CSSOM and render tree, so it can’t paint anything, jusqu’à ceux fichiers are downloaded and parsed.
Élevé TTFB — FCP can’t fire avant bytes arrive. A slow server is the premier domino, and it’s à l’intérieur the FCP measurement.
Chaîne de redirectionss — every redirection is a complet round-trip ajouté avant the premier byte.
Webfont chargement strategy — font-display: block (or aucun rule) peut leave text invisible pour up to ~3 seconds. Même si paint technically fires on a background, the utilisateur sees nothing utile.

Comment corriger it

The complet liste, but with a priority order the docs don’t give vous. Ces are the courant levers, pas universal ones — vérifier votre propre trace or filmstrip premier to voir qui resource or phase is en réalité delaying votre FCP candidate avant reaching pour fixes (preconnect, preload, a font-display modifier) que may pas appliquer to votre page:

Do ces premier (biggest wins):

Eliminate render-blocking CSS and JavaScript. Inline the critical, above-the-fold CSS directement in <head>; charger the rest asynchronously; ajouter async/defer to non-critical scripts. Repositioning a <link> tag fait pas aider — le navigateur won’t paint jusqu’à tout CSS is chargé and parsed regardless of où the tag sits.
Reduce TTFB (server réponse temps). Mise en cache, a CDN, a faster origin — anything que obtient the premier byte out sooner directement shaves FCP.
Fix font chargement. Utiliser font-display: swap (montre fallback text immédiatement, swaps in the web font quand ready) or font-display: optional (skips the web font si it isn’t déjà mis en cache). Éviter font-display: block pour critical text — it’s the worst pour FCP.

Alors tidy up the rest:

Preconnect to requis origins with <link rel="preconnect"> — establishing early connections to important third-party origins peut enregistrer 100–500 ms.
Preload clé requêtes (<link rel="preload">) pour a critical font or the LCP image.
Minify CSS, supprimer unused CSS, supprimer unused JavaScript — plus petit fichiers parse and unblock paint faster.
Éviter multiple redirections, éviter enormous network payloads, serve static assets with an efficient cache policy, éviter an excessive DOM size, and minimize critical requête depth. General payload hygiene que tout feeds premier paint.

The FCP → TTFB → LCP diagnostic chain

Ce is how I’d en réalité utiliser FCP, and it’s the framing the docs gesture at but don’t develop. Treat the three chargement metrics as un workflow:

FCP is élevé → vérifier pour ressources qui bloquent le rendu (CSS/JS in <head>). That’s the la plupart courant causer and the fastest win.
Aussi vérifier TTFB — parce que FCP inclut it, a slow server inflates FCP avant quelconque render-blocking même enters the picture. web.dev’s guidance: parce que TTFB precedes les deux FCP and LCP, votre serveur devrait respond fast suffisant que the 75th percentile of utilisateurs hit a “good” FCP.
Ces même problems souvent cascade into LCP — the metric that’s en réalité a ranking signal — parce que FCP and LCP frequently share root causes. That’s an overlap worth checking, pas a guarantee: LCP has factors of its propre (the size, priority, and charger chemin of its spécifique largest element), so fixing FCP’s causes doesn’t promise a fixed LCP. It’s the correct premier placer to regarder, pas the dernier step.

That’s the valeur of FCP pour an SEO: it’s a cheap, early lire on si the chargement chemin is sain, avant the plus selective LCP measurement même completes.

AI summary

A condensed prendre on the Avancé version:

FCP = temps from navigation commencer to quand quelconque content premier renders — text, images (incl. background), <svg>, or non-white <canvas>. It’s the “is anything on screen yet?” signal.
FCP n’est pas a Core Web Vital. The ranking signals are LCP, INP, CLS. FCP is a supplementary, lab-and-field diagnostic metric — pas a direct ranking factor.
It’s a building block of LCP (FCP se produit at or avant LCP), so it souvent catches the même ressources qui bloquent le rendu and slow TTFB que hurt LCP — qui fait affecter rankings — but fixing FCP’s causes doesn’t guarantee LCP is fixed; LCP has factors of its propre.
Field thresholds (CrUX p75): Bon ≤ 1,8 s · nécessite improvement ≤ 3,0 s · poor > 3,0 s.
Lab ≠ field, and “field is always higher” is a tendency, pas a rule. Lighthouse desktop’s ~0,9 s “green” line is stricter que the 1,8 s field threshold parce que it’s un clean run on fixed conditions; field/CrUX aggregates réel devices, networks, cache states, and navigation types (notamment bfcache restores and prerendered pages). Match populations avant reading a gap as a problem — utiliser field pour votre real-world number, lab pour diagnosis.
FCP vs FP: Premier Paint fires on quelconque paint (même a background color); FCP nécessite eligible content (text, images incl. background images, SVG, non-white canvas). FP ≤ FCP toujours.
FCP vs LCP: FCP = quelconque eligible content; LCP = largest eligible candidate. Neither proves lune page’s réel principal content is complet or utile — they’re proxies. Fast FCP + slow LCP is a réel, courant gap.
Lighthouse 10 (current as of ce writing) weight: 10% — TBT 30%, LCP 25%, CLS 25%, FCP 10%, Speed Index 10%; weights shift entre Lighthouse versions.
Top fixes, in order: eliminate render-blocking CSS/JS → reduce TTFB → fix fonts (font-display: swap/optional) → preconnect/preload → minify/cache/DOM hygiene.

Documentation officielle

Primary-source documentation on FCP from Google.

web.dev (Google)

Premier affichage de contenu (FCP) — Philip Walton’s canonical definition, the “what counts as content” liste, the 1,8 s threshold, the Clé Point à propos de TTFB/redirections, and how to mesurer FCP with the Paint Timing API and the web-vitals library.
Web Vitals — où FCP sits: an “Other Web Vital,” supplementary to the Core Web Vitals (LCP, INP, CLS), utile pour diagnosing LCP.
Plus grand affichage de contenu (LCP) — the FCP-vs-LCP distinction and how the two relate.
Temps to Premier Byte (TTFB) — pourquoi TTFB precedes (and is inclus in) FCP.
User-centric performances metrics — FCP’s classification as les deux a lab and a field metric.

Lighthouse / Chrome Developers

Premier affichage de contenu audit — the Lighthouse desktop rating bands (green ≤ 0,9 s) and how the FCP score is computed contre HTTP Archive données.
Lighthouse performances scoring — the metric weights, notamment FCP at 10% of the Performances score in Lighthouse 10.

Recherche Google Central

Core Web Vitals & Recherche Google — the ranking page; listes LCP, INP, and CLS. FCP n’est pas on it, qui is the point.

Quotes from the source

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

web.dev — the definition

“First Contentful Paint (FCP) measures the time from when the user first navigated to the page to when any part of the page’s content is rendered on the screen.” — Philip Walton, Premier affichage de contenu (FCP), web.dev (mis à jour Dec 6 2023). Jump to quote

web.dev — the threshold

“sites should strive to have a First Contentful Paint of 1.8 seconds or less.” — même source. Jump to quote

web.dev — ce que FCP inclut (the Clé Point)

“FCP includes any unload time from the previous page, connection set up time, redirect time, and Time To First Byte (TTFB) which can be significant when measured in the field.” — même source.

web.dev — FCP’s role relative to the Core Web Vitals

“the metrics Time to First Byte (TTFB) and First Contentful Paint (FCP) are both vital aspects of the loading experience, and are both useful in diagnosing issues with LCP (slow server response times or render-blocking resources, respectively).” — Web Vitals, web.dev. Jump to quote

Lighthouse — how the FCP score is computed

“Your FCP score is a comparison of your page’s FCP time and FCP times for real websites, based on data from the HTTP Archive.” — Premier affichage de contenu audit, developer.chrome.com.

Lighthouse — how the Performances score fonctionne

“The Performance score is a weighted average of the metric scores.”
“The weightings have changed over time because the Lighthouse team is regularly doing research and gathering feedback to understand what has the biggest impact on user-perceived performance.” — Lighthouse performances scoring, developer.chrome.com.

Remarque: the web.dev and Chrome Developers pages ci-dessus render largely as static HTML and the deep liens target the exact verbatim strings. A couple of passages (the Clé Point callout and the Lighthouse score-methodology lines) don’t have stable text-fragment anchors and are quoted sans a #:~:text= deep lien; confirmer les contre the live pages avant treating quelconque quote as final. Lighthouse weights are quoted pour Lighthouse 10 — re-verify si a newer Lighthouse version has shipped.

Slow-FCP triage checklist

Quand FCP is élevé, fonctionner bas ce liste in order — it’s roughly biggest-win-first:

FCP cheat sheet

Field thresholds (CrUX, 75th percentile)

FCP temps	Rating
≤ 1,8 s	Bon
1,8 – 3,0 s	Nécessite improvement
> 3,0 s	Poor

Lighthouse desktop rating (lab — remarque: stricter que field)

FCP temps	Color
0 – 0,9 s	Green (fast)
0,9 – 1,6 s	Orange (moderate)
Over 1,6 s	Red (slow)

Lighthouse 10 Performance-score weights (current as of ce writing — weights shift entre Lighthouse versions)

Metric	Weight
Total Blocking Temps	30%
Plus grand affichage de contenu	25%
Décalage cumulatif de mise en page	25%
Premier affichage de contenu	10%
Speed Index	10%

The three chargement metrics, untangled

Metric	Fires quand…	Core Web Vital?
Premier Paint (FP)	le navigateur paints anything, même a background color	Aucun
Premier affichage de contenu (FCP)	quelconque contenu réel paints (text/image/SVG/canvas)	Aucun (diagnostic)
Plus grand affichage de contenu (LCP)	the largest viewport element renders	Yes

Order of events: FP ≤ FCP ≤ LCP.

Ce que counts as “content” pour FCP text · images (incl. background images) · <svg> elements · non-white <canvas> elements

Fast facts

FCP’s clock starts at navigation — it inclut redirection temps, connection setup, and TTFB.
FCP is measurable in les deux lab and field.
font-display: utiliser swap/optional; éviter block (invisible text up to ~3 s).
Preconnect to third-party origins peut enregistrer 100–500 ms.

Outils pour measuring FCP

Field (real-user) données

PageSpeed Insights — montre votre URL’s CrUX p75 FCP (field) alongside a Lighthouse (lab) run.
Chrome Utilisateur Experience Report (CrUX) — the real-user dataset behind the field numbers, via the API or BigQuery.
web-vitals JavaScript library — drop onFCP(console.log) (or send it to votre analytics) to capture FCP from votre propre visitors; it handles bfcache and background-tab edge cas.

Lab (simulated) données

Lighthouse — in Chrome DevTools, PageSpeed Insights, or the CLI. Utiliser it to diagnose FCP (the “Eliminate render-blocking resources” audit is the clé un).
Chrome DevTools Performances panel — voir exactly quand premier paint and premier affichage de contenu fire on a recorded charger.

Mesurer it yourself with the Paint Timing API

new PerformanceObserver((entryList) => {
  for (const entry of entryList.getEntriesByName('first-contentful-paint')) {
    console.log('FCP candidate:', entry.startTime, entry);
  }
}).observe({type: 'paint', buffered: true});

Or utiliser the web-vitals library (recommended)

import {onFCP} from 'web-vitals';
onFCP(console.log);

A few caveats the raw API doesn’t handle que the web-vitals library fait: it ignores FCP fired pour background tabs, encore reports FCP quand une page is restored from the back/forward cache (a fresh navigation event doesn’t automatically fire pour a bfcache restore, so it nécessite explicit handling), and uses activationStart plutôt que navigation commencer as the clock origin pour prerendered pages. Cross-origin iframe paint timing remains a connu gap — une page whose principal content renders à l’intérieur un peut montrer a misleadingly fast FCP.

FCP mistakes que hide the réel bottleneck

Treating FCP as a Core Web Vital. FCP is a utile diagnostic, but LCP, INP, and CLS are the Core Web Vitals utilisé in Google’s ranking systems. Utiliser FCP to investigate the blank-screen phase, pas as a substitute pour field CWV données.
Optimizing a tiny logo parce que it becomes the premier paint. An précédent but meaningless paint peut améliorer FCP pendant que the utile page content encore arrives late. Vérifier LCP and the filmstrip alongside FCP so the modifier improves ce que a visitor en réalité sees.
Starting with image compression quand lune page is blank. Si nothing peut paint, the usual blockers are server réponse temps, render-blocking CSS, synchronous JavaScript, or fonts. Follow la requête waterfall avant modification unrelated assets.
Comparing unrelated Lighthouse runs. Device emulation, network conditions, cache state, and run-to-run variation tout déplacer a lab FCP. Comparer repeated runs sous the même settings and confirmer le résultat with field données où disponible.

The blank-screen budget

Break FCP into three consecutive questions au lieu de treating the final number as un problem:

How long avant the HTML arrives? Inspect TTFB. A slow réponse signifie the navigateur ne peut pas begin utile fonctionner, so commencer with le serveur, cache, redirections, or connection setup.
How long avant le navigateur peut render? Inspect render-blocking stylesheets, synchronous scripts, and font behavior. The HTML may be présent pendant que the principal thread or render chemin is encore blocked.
Ce que en réalité becomes the premier content? Utiliser a filmstrip or trace to confirmer que the premier paint is meaningful text or imagery, pas a token element que rend the metric regarder meilleur sans improving the experience.

The framework garde fixes in order: delivery premier, rendering second, usefulness third. Re-run the même lab profile après chaque modifier so vous know qui phase déplacé.

Testez vos connaissances: Premier affichage de contenu

Five rapide questions on ce que FCP measures and how to diagnose it. Pick an réponse pour chaque, alors vérifier.

Ressources utiles

Google / web.dev

Premier affichage de contenu (FCP) — the canonical référence: definition, thresholds, measurement code, and the complet optimization liste.
Web Vitals — how FCP relates to the Core Web Vitals and pourquoi it’s a diagnostic metric.
Plus grand affichage de contenu (LCP) — the metric FCP helps vous diagnose, and a Core Web Vital.
Temps to Premier Byte (TTFB) — le serveur-response metric que lives à l’intérieur FCP.

Lighthouse

Premier affichage de contenu audit — desktop rating bands and how the score is computed.
Lighthouse performances scoring — the metric weights, FCP at 10%.

My connexe writing

The Beginner’s Guide to SEO technique — où vitesse de page fits in the bigger picture.
Core Web Vitals: Ce que Ils Are & How to Améliorer Les — the ranking-signal metrics FCP feeds into.

From autour the industry

Premier affichage de contenu (FCP) — Philip Walton’s canonical Google article: definition, thresholds, Paint Timing API code, and the complet optimization liste.
Web Vitals — Google’s framework explaining où FCP sits (an “Other Web Vital,” supplementary to the Core Web Vitals) and its role in diagnosing LCP.
Premier affichage de contenu audit — Chrome Developers doc covering Lighthouse desktop rating bands and how the FCP score is computed contre HTTP Archive données.
Temps to Premier Byte (TTFB) — Google’s guide on pourquoi TTFB precedes and is inclus in FCP, and how a slow server eats votre FCP budget avant le navigateur paints a unique pixel.
Eliminate ressources qui bloquent le rendu — Chrome Developers guide on the #1 FCP killer: CSS and synchronous JS in <head> que block le navigateur from painting.
Garantir text remains visible during webfont charger — Chrome Developers audit explaining font-display valeurs and pourquoi block delays FCP pendant que swap or optional garde text visible.
Premier affichage de contenu — NitroPack’s practical FCP guide with CMS-specific optimization tips and a clair field-vs-lab explanation.

Stats worth citing

Bon FCP = ≤ 1,8 s at the 75th percentile of réel utilisateurs; needs-improvement up to 3,0 s; poor au-delà que (field/CrUX thresholds). Source
Lighthouse desktop is stricter: ~0–0,9 s is “green,” parce que the lab runs a throttled, simulated environment plutôt que real-world conditions. Source
FCP is 10% of the Lighthouse 10 Performances score (current as of ce writing — weights shift entre Lighthouse versions) — alongside TBT 30%, LCP 25%, CLS 25%, and Speed Index 10%. Source
Preconnecting to third-party origins peut enregistrer 100–500 ms of charger temps by establishing early connections. Source

Journal des modifications

Mis à jour le 17 juil. 2026.

Résumé éditorial et détails enregistrés des changements.

Détails des changements

Les notes détaillées des changements sont actuellement disponibles en anglais.

Comparaison complète indisponible — aucun instantané antérieur n’a été archivé pour cette révision.