Temps to Premier Byte (TTFB)

TL;DR — Temps to Premier Byte is how long le navigateur waits, après it demande pour une page, avant the very premier byte of the réponse comes back. It’s a mesurer of server responsiveness. A bon TTFB is 0,8 seconds or moins. It is pas a Core Web Vital — but a slow un drags bas the metrics que are, parce que nothing on the page peut commencer jusqu’à que premier byte montre up.

Ce que TTFB is

Quand vous click a lien, votre navigateur sends une requête to a server and alors waits. Temps to Premier Byte (TTFB) is the length of que wait — from the moment the requête starts to the moment the premier byte of la réponse begins to arrive.

It isn’t simplement “how fast the server thinks.” A lot se produit avant votre navigateur même talks to the correct machine: it may follow a redirection, regarder up the domain in DNS, ouvrir a connection, and negotiate the secure (TLS) handshake. TTFB rolls tout of que ensemble, alors adds le serveur’s propre processing temps, and arrête the clock at the premier byte back.

Ce que counts as bon

Google’s web.dev guidance is simple: aim pour a TTFB of 0,8 seconds or moins. Ci-dessus 1,8 seconds is considéré poor. La plupart sites devrait be able to hit the bon mark — and nombreux don’t, qui is exactly pourquoi it’s worth checking.

Pourquoi c’est important même though it isn’t a “core” metric

You’ll hear a lot à propos de Core Web Vitals — LCP, INP, and CLS. TTFB n’est pas un of les. But it sits underneath the ones à propos de chargement: les deux Premier affichage de contenu and Plus grand affichage de contenu inclure TTFB in leur measurement. Le navigateur can’t paint anything jusqu’à the bytes commencer arriving. So a slow TTFB puts a ceiling on how fast votre page peut possibly feel.

The practical takeaway: TTFB doesn’t obtenir vous ranked by itself, but a bad un quietly holds back the metrics que do.

The usual fixes, in plain terms

• Utiliser a CDN. It puts a copy of votre site on servers physically closer to votre visitors, so the round trip is shorter.
• Cache votre pages. Si le serveur peut hand back a ready-made copy au lieu de rebuilding lune page every temps, the premier byte comes beaucoup sooner.
• Obtenir meilleur hosting. A faster server and database is the la plupart direct fix.
• Cut redirections. Every redirection is an supplémentaire round trip avant the réel page même starts chargement.

Vouloir the complet version — the exact thresholds, the LCP relationship, the Lighthouse-vs-CrUX threshold confusion, Early Hints, and how to mesurer it? Switch to the Avancé tab.

TL;DR — TTFB is the temps from the commencer of la requête to quand the premier byte of la réponse arrives — the sum of redirection temps, service worker startup, DNS lookup, connection + TLS negotiation, and la requête itself, up to que premier byte. It is pas a Core Web Vital; it’s a foundational, diagnostic metric que feeds FCP and LCP. web.dev: bon is ≤0,8 s, poor is >1,8 s (75th percentile). It’s les deux a field and a lab metric. Lighthouse’s “Reduce server response times” audit is narrower — it flags server temps over ~600 ms, pas complet TTFB, and as of Lighthouse 13 it lives à l’intérieur the “Document request latency” insight. Fix it with a CDN, edge/HTML mise en cache, faster hosting, fewer redirections, 103 Early Hints, and efficient TLS. And a élevé TTFB doesn’t toujours mean a slow site.

Ce que TTFB en réalité measures

TTFB measures the temps entre starting to navigate to une page and quand the premier byte of la réponse begins to arrive. The chose personnes obtenir incorrect is treating it as pure backend processing temps. It isn’t. It’s the sum of everything que has to finish avant que premier byte peut come back:

1. Redirection temps
2. Service worker startup temps (si un s’applique)
3. DNS lookup
4. Connection and TLS negotiation
5. La requête — up jusqu’à the point the premier byte of la réponse has arrived

Server processing is in là, but so is the whole connection-setup tax. Que distinction matters the moment vous commencer reading outils, parce que ils don’t tout mesurer the même slice (plus on que ci-dessous).

It n’est pas a Core Web Vital

I’ll dire it plainly parce que it’s the unique la plupart courant misconception: TTFB n’est pas a Core Web Vital. The three Core Web Vitals are LCP (chargement), INP (interactivity), and CLS (visual stability). TTFB is a foundational, diagnostic metric — Google’s propre framing is que it’s “a foundational metric pour measuring connection setup temps and web server responsiveness in les deux the lab and the field.”

Google is aussi explicit que vous don’t strictly have to hit the bon TTFB threshold: parce que it isn’t a Core Web Vital, it’s “pas absolutely necessary que sites meet the ‘bon’ TTFB threshold, provided que it doesn’t impede leur ability to score bien on the metrics que matter.” Que dernier clause is the catch — pour la plupart sites a bad TTFB absolutely fait impede the metrics que matter.

How it caps FCP and LCP

TTFB precedes every user-centric chargement metric. Les deux Premier affichage de contenu and Plus grand affichage de contenu inclure TTFB in leur measurement — the clock pour ceux metrics is déjà running pendant que vous wait pour the premier byte. web.dev breaks LCP into sub-parts and TTFB is the premier of les, qui is pourquoi vous pouvez’t have a fast LCP sitting on top of a slow TTFB.

Ce is aussi où the real-world données obtient pointed. The HTTP Archive’s Web Almanac trouvé que on sites with poor LCP, TTFB alone was eating roughly 2,27 seconds — nearly the entier 2,5-second “good LCP” budget — avant quelconque image or text même commencé to render. Si votre LCP is bad and votre on-page content semble optimized, TTFB is the premier placer I’d regarder.

So the ranking story is indirect but réel: TTFB n’est pas a Google ranking signal (the ranking signals are LCP, INP, and CLS — TTFB isn’t named in que définir). But it’s baked into LCP, qui is a ranking signal. The chemin runs via LCP, pas via TTFB directement.

Thresholds: bon, nécessite improvement, poor

web.dev’s guidance, mesuré at the 75th percentile of real-user loads:

• Bon: ≤ 0,8 s
• Poor: > 1,8 s

“Most sites should strive to have a TTFB of 0.8 seconds or less.” Worth knowing the history: Google déplacé the “good” line from 500 ms to 800 ms back in 2022, and older données was recalculated sous the nouveau standard — so don’t comparer raw historical TTFB numbers sans checking qui threshold ils utilisé.

The 600 ms vs 800 ms confusion

Ce trips up a lot of personnes, so it’s worth being precise. Là are two différent numbers floating autour:

• CrUX / web.dev TTFB threshold: 800 ms. Ce is the field threshold pour complet TTFB (DNS + connection + TLS + redirections + server temps).
• Lighthouse “Reduce server response times” audit: ~600 ms. Ce is a lab audit que flags quand le navigateur waits plus que à propos de 600 ms pour le serveur to respond to the principal document requête. Crucially, it measures server réponse temps seulement — it ne fait pas inclure DNS, connection setup, or TLS.

So the Lighthouse number semble stricter, but it’s measuring a narrower slice. As the docs put it, “server réponse temps is seulement partie of the complet Temps to Premier Byte (TTFB).” Don’t treat a passing Lighthouse audit as proof of a bon field TTFB, and don’t panic que 600 < 800 signifie the thresholds contradict chaque autre — ils mesurer différent choses.

Un version remarque: as of Lighthouse 13, ce audit ne … plus stands alone — it’s been folded into the broader “Document request latency” insight. The underlying ~600 ms server-response vérifier is the même; it’s simplement surfaced differently depending on qui Lighthouse version generated votre report.

Field and lab — les deux

TTFB is un of the metrics vous pouvez lire in les deux worlds. In the field, it comes from CrUX (réel Chrome utilisateurs), surfaced in PageSpeed Insights and Search Console. In the lab, Chrome DevTools étiquettes it “Waiting (TTFB)” in the Network panel waterfall (“the browser is waiting for the first byte of a response”), and outils comme WebPageTest and Lighthouse report it aussi. Un field caveat: in CrUX, TTFB is encore treated as somewhat experimental — it excludes some avancé navigation types comme prerendered and back/forward-cache navigations, so field averages peut lire a touch pessimistic relative to ce que utilisateurs en réalité feel.

A élevé TTFB doesn’t toujours mean a slow site

Here’s the nuance que the threshold numbers hide. A server-rendered page peut post a plus élevé TTFB que a client-rendered un and encore deliver meilleur FCP and LCP — parce que quand que premier byte finalement arrives, it’s complet HTML le navigateur peut paint immédiatement, plutôt que a thin shell que alors has to récupérer and run a JavaScript bundle avant anything apparaît. Google dit it directement: “a server-rendered site que ne fait pas exiger as beaucoup client-side fonctionner pourrait have a plus élevé TTFB, but meilleur FCP and LCP valeurs que an entirely client-rendered experience.”

The flip side: pour a client-rendered single-page app, TTFB determines quand the JavaScript bundle même starts chargement, so a low TTFB matters plus là, pas moins. Don’t optimize TTFB in a vacuum — optimize the whole chargement chain, and judge TTFB by ce que it fait to FCP and LCP.

How to améliorer TTFB

Roughly in priority order:

• Commencer with hosting. A slow backend or database requête is a tax on every unique requête, and aucun amount of front-end fonctionner removes it. Ce is the premier chose to considérer.
• Utiliser a CDN. A CDN solves the proximity problem — a distributed network of edge servers caches resources physically closer to votre utilisateurs, cutting the speed-of-light cost of the connection and TLS handshake. It’s the highest-ROI fix pour la plupart sites, parce que geographic distance from votre origin is a structural tax nothing on the backend peut erase. The caveat: pour entièrement dynamic, personalized content que can’t be mis en cache, a CDN adds a hop sans a cache-hit payoff — là the réponse is backend optimization, edge compute, or streaming.
• Cache votre HTML, même briefly. Même a short cache temps helps a busy site noticeably: seulement the premier visitor in que window pays the complet latency back to the origin; everyone sinon obtient the mis en cache copy.
• Eliminate redirections. Redirections are a courant contributor to élevé TTFB — chaque un is a round trip avant the réel réponse starts. Cut the ones sous votre contrôler.
• Stream markup to le navigateur. Navigateurs traiter markup efficiently quand it’s streamed in chunks as it arrives. Nombreux SSR frameworks prise en charge streaming but it’s left switched off; turning it on peut drop TTFB on dynamic pages with aucun infrastructure modifier at tout.
• Utiliser 103 Early Hints. The 103 code d’état is a preliminary réponse le serveur peut send pendant que the backend is encore preparing the markup, hinting to le navigateur to begin downloading render-critical resources early. It doesn’t lower TTFB itself — in fact a 103 peut count as the “first byte” — but it shrinks the impact of a élevé TTFB. Shopify and Cloudflare have reported several hundred milliseconds of LCP improvement from it, in some cas fermer to a second.
• Negotiate TLS efficiently and optimize service worker startup. A service worker que hasn’t commencé yet adds its startup temps to TTFB; une fois running, its cache (stale-while-revalidate, or an app-shell model pour SPAs) peut dramatically reduce TTFB.

Où sites en réalité stand

The raison ce is worth votre attention: it’s a stubborn problem à travers the web. The Web Almanac’s mobile good-TTFB rate has barely déplacé in five années — hovering autour 41–42% — meaning a majority of mobile sites encore don’t have a “good” TTFB. Que stagnation is, frankly, an opportunity. Pour a server-heavy site failing LCP, TTFB is usually the highest-leverage fix on the board.

Ce page is partie of the web-performance cluster, qui sits sous Core Web Vitals. Pour the metrics TTFB feeds into, voir Plus grand affichage de contenu and Premier affichage de contenu; to mesurer it on réel utilisateurs and in the lab, voir CrUX, PageSpeed Insights, and Lighthouse.

AI summary

A condensed prendre on the Avancé version:

• TTFB = the wait pour the premier byte. Temps from the commencer of la requête to quand the premier byte of la réponse arrives — the sum of redirection temps, service worker startup, DNS lookup, connection + TLS negotiation, and la requête itself. Pas simplement server processing.
• It n’est pas a Core Web Vital. The Core Web Vitals are LCP, INP, and CLS. TTFB is a foundational, diagnostic metric.
• It caps FCP and LCP. Les deux inclure TTFB, so a slow TTFB sets a ceiling on how fast une page peut charger. On poor-LCP sites, TTFB alone was ~2,27 s — nearly the whole 2,5 s good-LCP budget.
• Rankings: indirect. TTFB isn’t a Google ranking signal, but it’s baked into LCP, qui is. The chemin runs via LCP.
• Thresholds (75th pct): bon ≤ 0,8 s, poor > 1,8 s. The “good” line déplacé from 500 ms to 800 ms in 2022.
• 600 ms vs 800 ms: Lighthouse’s “Reduce server response times” audit flags ~600 ms of server temps seulement — narrower que the 800 ms full-TTFB field threshold. “Server response time is only part of the full TTFB.” As of Lighthouse 13 ce audit lives à l’intérieur the “Document request latency” insight.
• Field and lab: CrUX/PSI/Search Console (field); DevTools “Waiting (TTFB)”, WebPageTest, Lighthouse (lab).
• Élevé TTFB ≠ slow site: an SSR page peut have a plus élevé TTFB but meilleur FCP/LCP que a client-rendered un, parce que the premier byte is complet HTML.
• Fixes (priority): hosting premier, alors CDN, HTML mise en cache, fewer redirections, streaming, 103 Early Hints, efficient TLS, service worker startup.
• State of the web: mobile good-TTFB has been flat at ~41–42% pour five années — a réel opportunity.

Documentation officielle

Primary-source documentation from Google’s Chrome and web.dev teams.

• Temps to Premier Byte (TTFB) — the definition, the five components, the 0,8 s / 1,8 s thresholds, pourquoi it isn’t a Core Web Vital, and its relationship to FCP and LCP.
• Optimize TTFB — the optimization guide: hosting premier, alors CDN, mise en cache, redirections, streaming, 103 Early Hints, and service workers.
• Reduce server réponse times — the Lighthouse audit (~600 ms server-time threshold) and how it differs from complet TTFB. As of Lighthouse 13 it’s folded into the “Document request latency” insight.
• Web Vitals — où TTFB sits in the metric taxonomy: a supplementary/diagnostic metric, with LCP, INP, and CLS as the Core Web Vitals.
• Plus grand affichage de contenu (LCP) — confirms LCP inclut TTFB delays.
• Premier affichage de contenu (FCP) — confirms FCP inclut TTFB, and listes “reduce server response times (TTFB)” as a fix.
• Core Web Vitals (Recherche Google Central) — the ranking-signal docs nom LCP, INP, and CLS seulement; TTFB n’est pas listed.
• 103 Early Hints — the early réponse code, navigateur/server prise en charge, and real-world results.

Quotes from the source

On-the-record statements from Google’s web.dev and Chrome teams. Chaque lien is a deep lien que jumps to the quoted passage on the source page où un was verified.

web.dev — ce que TTFB is

• “TTFB is a metric que measures the temps entre starting navigating to une page and quand the premier byte of une réponse begins to arrive.” Jump to quote
• “Temps to Premier Byte (TTFB) is a foundational metric pour measuring connection setup temps and web server responsiveness in les deux the lab and the field.” Jump to quote

web.dev — thresholds

• “Bon TTFB valeurs are 0,8 seconds or moins, and poor valeurs are supérieur que 1,8 seconds.” Jump to quote

web.dev — pas a Core Web Vital

• “Parce que TTFB isn’t a Core Web Vitals metric, it’s pas absolutely necessary que sites meet the ‘bon’ TTFB threshold, provided que it doesn’t impede leur ability to score bien on the metrics que matter.” Jump to quote

web.dev — relationship to FCP and LCP

• “Parce que TTFB precedes user-centric metrics tel as Premier affichage de contenu (FCP) and Plus grand affichage de contenu (LCP)…” Jump to quote
• On a server-rendered site: “a server-rendered site que ne fait pas exiger as beaucoup client-side fonctionner pourrait have a plus élevé TTFB, but meilleur FCP and LCP valeurs que an entirely client-rendered experience.” (web.dev, “Temps to Premier Byte”)

Lighthouse — server réponse temps vs complet TTFB

• “Server response time is only part of the full Time to First Byte (TTFB).” (Lighthouse, “Reduce server response times.”)

Patrick Stox — on TTFB’s status (from my Ahrefs Core Web Vitals guide)

• “Là are additional Web Vitals que serve as proxy measures or supplemental metrics but ne sont pas utilisé in the ranking calculations. The Web Vitals metrics pour visual charger inclure Temps to Premier Byte (TTFB) and Premier affichage de contenu (FCP).” Lire the guide

TTFB triage checklist

Quand PageSpeed Insights, Search Console, or Lighthouse flags a slow server réponse, fonctionner bas ce liste:

• Confirmer ce que you’re looking at — complet field TTFB (≤0,8 s bon) or the Lighthouse “Reduce server response times” audit (~600 ms, server temps seulement). Ils aren’t the même number.
• Vérifier the field, pas simplement the lab — pull TTFB from CrUX viune pageSpeed Insights or the Search Console Core Web Vitals report, at the 75th percentile.
• Regarder at si TTFB is the chose capping votre LCP — si LCP is poor and the page content is optimized, TTFB is the premier suspect.
• Count votre redirections — eliminate quelconque chaîne de redirectionss sous votre contrôler on clé entry URLs.
• Confirmer a CDN is serving votre utilisateurs (edge PoPs fermer to votre audience), and que HTML/edge mise en cache is en réalité hitting, pas simplement static assets.
• Profile the backend — slow database requêtes or heavy server-side fonctionner on the principal document requête.
• Vérifier TLS is efficient (modern protocol, session resumption) and DNS is fast.
• Si lune page is dynamic SSR, vérifier si streaming is enabled in votre framework — it’s souvent off by par défaut.
• Considérer 103 Early Hints pour render-critical resources si votre serveur/CDN supports it.
• Si vous utiliser a service worker, vérifier its startup isn’t ajout to TTFB on premier charger, and que its cache strategy helps repeat loads.

TTFB cheat sheet

Ce que TTFB is the sum of

1. Redirection temps
2. Service worker startup (si quelconque)
3. DNS lookup
4. Connection + TLS negotiation
5. La requête — up to the premier byte of la réponse

Thresholds (75th percentile of real-user loads)

Two thresholds, two scopes

Fast facts

• TTFB is pas a Core Web Vital. The Core Web Vitals are LCP, INP, CLS.
• It’s les deux a field and a lab metric.
• Les deux FCP and LCP inclure TTFB — it sets a ceiling on les.
• Ranking impact is indirect, via LCP — TTFB itself isn’t a ranking signal.
• DevTools étiquettes it “Waiting (TTFB)” in the Network panel.
• The “good” line déplacé from 500 ms → 800 ms in 2022.

Fix priority: hosting → CDN → HTML/edge mise en cache → cut redirections → stream markup → 103 Early Hints → efficient TLS → service worker startup.

Outils pour measuring TTFB

• PageSpeed Insights — the easiest field lire: montre votre CrUX TTFB (réel Chrome utilisateurs) alongside a lab run, pour une URL or origin.
• Search Console — Core Web Vitals report — field données grouped by URL pattern; the placer to spot TTFB problems at scale.
• CrUX (Chrome Utilisateur Experience Report) — the underlying field dataset; queryable directement via the CrUX API or BigQuery pour historical trends.
• Chrome DevTools — Network panel — hover the principal document requête and lire the “Waiting (TTFB)” timing pour a precise lab breakdown of connection vs server temps.
• Lighthouse — runs the “Reduce server response times” audit (~600 ms server-time flag); construit into DevTools and PageSpeed Insights. As of Lighthouse 13, ce vérifier surfaces à l’intérieur the “Document request latency” insight.
• WebPageTest — detailed waterfalls with TTFB broken out by connection phase, and multi-location/connection testing to isolate geographic latency.
• web-vitals JS library — collect TTFB (and the rest) from votre propre réel utilisateurs in the field and send it to votre analytics.

TTFB mistakes que lead to the incorrect fix

Appel every delay a server problem

TTFB inclut redirections, DNS, connection setup, TLS, service-worker startup, and server processing. Break la requête into phases avant modification application code or hosting.

Comparing Lighthouse’s 600 ms audit with the 800 ms field threshold

The Lighthouse audit is a narrower lab diagnostic, pendant que the 0,8-second guidance describes complet TTFB. Étiquette the source and scope quand reporting soit number.

Testing seulement from a emplacement near the origin

A nearby lab peut hide geographic latency. Comparer regions or utiliser real-user données avant assuming the même experience s’applique to the whole audience.

Chasing TTFB pendant que lune page is déjà fast

A élevé TTFB peut be compatible with a fast streamed or mis en cache experience. Vérifier si it en réalité constrains FCP or LCP avant prioritizing it over a plus grand bottleneck.

Diagnose a slow TTFB by symptom

The premier requête is slow but repeat requêtes are fast

Probable causer: cold caches, connection setup, or application warm-up. Fix: inspect cache headers and separate cold from warm tests. Confirmer: the waterfall montre qui connection or server phase disappears on the repeat requête.

TTFB is slow seulement in distant regions

Probable causer: physical distance to the origin or a CDN cache miss. Fix: serve cacheable HTML closer to utilisateurs and vérifier edge cache behavior. Confirmer: regional tests montrer a shorter wait sans modification the corps de la réponse.

UNE URL has beaucoup worse TTFB que its template peers

Probable causer: redirections, an uncached route, or expensive page-specific backend fonctionner. Fix: comparer the chaîne de redirections, cache status, and server timing with a sain peer. Confirmer: the outlier’s document requête moves back toward the template baseline.

DevTools and CrUX disagree

Probable causer: un lab requête ne peut pas represent the field’s devices, locations, cache states, and 75th percentile. Fix: utiliser the lab requête to diagnose and field données to judge prevalence. Confirmer: votre RUM distribution explique qui segment produces the slower aggregate.

Mesurer TTFB from the command line

Utiliser curl’s timing variables to separate the premier byte from DNS, connection, and TLS setup.

curl -sS -o /dev/null \
  -w 'dns=%{time_namelookup}s connect=%{time_connect}s tls=%{time_appconnect}s starttransfer=%{time_starttransfer}s total=%{time_total}s\n' \
  https://example.com/

time_starttransfer is the command’s TTFB-style measurement. Run several cold and warm requêtes from plus que un relevant region; a unique local sample n’est pas a field benchmark.

Lire Navigation Timing in le navigateur

const nav = performance.getEntriesByType('navigation')[0];
console.table({
  ttfb: Math.round(nav.responseStart - nav.requestStart),
  dns: Math.round(nav.domainLookupEnd - nav.domainLookupStart),
  connect: Math.round(nav.connectEnd - nav.connectStart),
});

Prove a TTFB modifier took effect

Edge-cache tester

Tester to run: requête the même document twice with curl -sS -D - -o /dev/null, alors inspect the CDN’s cache-status and age headers. Attendu result: the repeat requête is served from cache according to the CDN’s documented header. Échec interpretation: the route is bypassing or immédiatement expiring the cache. Monitoring window: immediate. Rollback trigger: personalized, authenticated, or stale HTML is served to the incorrect requête.

Redirect-removal tester

Tester to run: utiliser curl -sS -I on the final public URL and inspect the chaîne de redirections separately. Attendu result: the intended entry URL reaches the document sans an avoidable hop. Échec interpretation: routing or canonical-host rules encore ajouter a round trip. Monitoring window: immediate. Rollback trigger: the modifier breaks requis HTTP-to-HTTPS or hostname normalization.

Field TTFB tester

Tester to run: comparer post-release Navigation Timing or web-vitals TTFB by region and template with the pre-release baseline. Attendu result: p75 improves in the affected segments sans plus errors. Échec interpretation: the lab gain did pas reach réel utilisateurs or shifted fonctionner elsewhere. Monitoring window: as RUM trafic arrives; CrUX over its rolling window. Rollback trigger: error rate, cache correctness, or user-visible latency worsens.

TTFB metrics worth tracking

Real-user TTFB at p75

Metric: the 75th-percentile TTFB by template, region, and device class. Ce que it indique vous: how long the document requête delays la plupart réel visits avant rendering peut begin. How to pull it: Navigation Timing, the web-vitals library, CrUX, or PageSpeed Insights. Benchmark / realistic range: 0,8 seconds or moins is the bon target décrit in ce article; interpret segments separately. Cadence: weekly in RUM and monthly pour the rolling public field trend.

Cache-hit TTFB versus cache-miss TTFB

Metric: p75 TTFB split by the CDN’s cache outcome. Ce que it indique vous: si origin fonctionner or edge delivery owns the delay. How to pull it: join réponse cache-status headers with RUM or CDN logs. Benchmark / realistic range: utiliser le site’s propre regional baseline parce que provider, route, and personalization differ. Cadence: weekly and après cache-rule changements.

TTFB share of LCP

Metric: TTFB divided by the LCP duration pour the même visit. Ce que it indique vous: si server and connection temps are the limiting partie of the chargement experience. How to pull it: collect TTFB and LCP ensemble in RUM. Benchmark / realistic range: aucun universal percentage is honest; prioritize TTFB quand it consistently consumes a grand partie of LCP. Cadence: monthly by template.

Ressources utiles

My connexe writing

• Core Web Vitals: A Beginner’s Guide — où TTFB fits among the chargement metrics, and pourquoi it’s a supplemental metric plutôt que a ranking signal.
• The Beginner’s Guide to SEO technique — the bigger picture site performances sits à l’intérieur.

Official

• web.dev’s TTFB and Optimize TTFB — the two definitive pages.
• The Chrome team’s 103 Early Hints write-up, with the Shopify/Cloudflare results.

Données

• The HTTP Archive Web Almanac — Performances chapter — the long-run TTFB and LCP field données pour the whole web.

From autour the industry

• Cloudflare blog: Early Hints — Cloudflare’s propre write-up on shipping 103 Early Hints, notamment real-world results and CDN implementation details.
• web-vitals JS library (GitHub) — the canonical library pour collecting TTFB (and tout Web Vitals) from réel utilisateurs; utiliser ce to send field TTFB to votre propre analytics.
• HTTP Archive Web Almanac 2022 — Performances — historical baseline showing 40% mobile good-TTFB sous the then-new 800 ms threshold; utile pour multi-year trend context.
• Fastly — HTTP/2 Server Push vs Early Hints — CDN perspective on pourquoi Early Hints is replacing Server Push pour reducing TTFB impact.

Stats worth citing

• ~42% of mobile sites have a “good” TTFB — and it’s barely déplacé in five années. The Web Almanac’s mobile good-TTFB rate has hovered autour 41–42% à travers five années of données: a stubborn, web-wide stagnation. Source
• On poor-LCP sites, TTFB alone consumed ~2,27 seconds — nearly the entier 2,5-second “good LCP” threshold, avant quelconque content rendered. TTFB is the largest sub-part of LCP pour sites que échouer it. Source
• 103 Early Hints delivered several hundred milliseconds of LCP improvement in Shopify and Cloudflare testing — in some cas fermer to a second faster. Source
• The “good” TTFB line déplacé from 500 ms to 800 ms in 2022, and historical données was recalculated sous the nouveau standard — worth knowing avant comparing old TTFB numbers. Source

Testez vos connaissances: Temps to Premier Byte

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

Journal des modifications