Request duration del TTFB: riduci il tempo di elaborazione del server

La parte del server nel TTFB: come la chiamano DevTools e web-vitals, come Server-Timing mostra il passaggio lento e perché una cache di pagina viene prima.

  • Buono ≤ 0,8 s
  • Da migliorare ≤ 1,8 s
  • Scarso > 1,8 s
Arjen Karel
Aggiornato il · 11 min di lettura
Condividi

Request duration in breve

La request duration è l'ultima delle cinque fasi del Time to First Byte (TTFB): va dall'invio della richiesta dell'HTML fino all'arrivo del suo primo byte. È data dal server che genera la pagina più un round trip sulla rete. Sulla maggior parte dei siti è la quota maggiore del TTFB: riducila per prima, partendo da una cache di pagina.

Cos'è la request duration, ed equivale a "Waiting (TTFB)" nei DevTools?

La request duration è ciò che Chrome DevTools mostra nella scheda Timing del pannello Network come "Waiting for server response" (nelle versioni precedenti "Waiting (TTFB)"): un round trip di latenza più il tempo impiegato dal server per preparare la risposta. La libreria web-vitals riporta la stessa fase come requestDuration, CoreDash come Request nel suo Phase breakdown, e Lighthouse come server response time.

Inizia quando la connessione al server è pronta e termina quando il primo byte dell'HTML raggiunge il browser. Prima di essa si trovano le altre quattro parti del Time to First Byte: waiting, cache, DNS e connection. La fase di waiting riguarda perlopiù i redirect prima della richiesta; non corrisponde al "Waiting" dei DevTools.

La richiesta è stata la quota maggiore del TTFB al 75° percentile su 82 degli 86 siti CoreDash con almeno 1.000 caricamenti pagina da smartphone nei 28 giorni fino al 9 novembre 2026.

Cosa fa il server mentre il browser aspetta?

La richiesta viaggia verso il server e il primo byte torna indietro; nel mezzo, il server genera la pagina:

  1. Routing: il web server, come nginx o Apache, passa la richiesta all'applicazione.
  2. Avvio: l'applicazione carica il proprio codice; per ogni pagina generata, WordPress carica il core, ogni plugin attivo e il tema.
  3. Dati: l'applicazione interroga il database e chiama altri servizi, come un'API per le giacenze o i prezzi.
  4. HTML: il template trasforma questi dati nella pagina.
Timeline of one real first visit to a WordPress page, from the click to the first byte of the HTML, 875 milliseconds in total, split into the five parts of TTFB one after the other: waiting 174 ms (a redirect), cache 1 ms, DNS 23 ms, connection 20 ms and request 657 ms.

Una prima visita a una pagina WordPress non in cache, misurata in Chrome. Sugli 875 ms di TTFB, la richiesta ne ha impiegati 657.

In quel caricamento la connessione ha impiegato 20 ms per due round trip (TCP e TLS), quindi un singolo round trip è durato circa 10 ms. Circa 645 dei 657 ms sono serviti al server per generare la pagina. Nelle vicinanze del server, la request duration è quasi interamente tempo server; un visitatore lontano deve attendere in più il round trip.

Niente può essere disegnato a schermo prima che arrivi il primo byte dell'HTML, quindi la request duration si aggiunge anche al Largest Contentful Paint.

Quale passaggio sul server è lento? Lo mostra Server-Timing

Un header Server-Timing invia le metriche del server insieme all'HTML, con una voce per ogni passaggio: database, template, un'API esterna, cache hit o miss. Chrome DevTools mostra le voci nella scheda Timing della richiesta HTML, sotto "Waiting for server response", e uno strumento di real-user monitoring (RUM) le raccoglie dai visitatori.

Server-Timing: db;dur=53.2;desc="Database", tpl;dur=18.7;desc="Template", cache;desc="MISS"
Chrome DevTools, Network panel, Timing tab of the HTML request on a local WordPress test install: Waiting for server response 58.98 ms, and under Server Timing wp (WordPress and query) 27.80 ms and tpl (Template) 27.10 ms.

Un caricamento su un'installazione locale di test di WordPress, più lento con i DevTools aperti: le due voci di Server-Timing, 27,8 e 27,1 ms, rientrano nei 59 ms in cui il browser ha atteso il server.

Chiunque apra i DevTools può leggere l'header. Invia solo i nomi dei passaggi e le durate, mai una query, un percorso di file o un hostname interno, oppure invialo solo al personale autenticato (MDN).

Server-Timing in PHP

Misura ogni passaggio con hrtime(true) e invia l'header prima della pagina:

$t = hrtime(true);
$products = $pdo->query('SELECT * FROM products WHERE active = 1')->fetchAll();
$db = (hrtime(true) - $t) / 1e6;

$t = hrtime(true);
$html = renderTemplate('product-list', ['products' => $products]);
$tpl = (hrtime(true) - $t) / 1e6;

header(sprintf('Server-Timing: db;dur=%.1f;desc="Database", tpl;dur=%.1f;desc="Template"', $db, $tpl));
echo $html;

PHP invia gli header con il primo output che lascia il server. Qualsiasi chiamata a header() successiva viene scartata con l'avviso "headers already sent", quindi un template che stampa l'output man mano necessita dell'output buffering.

Server-Timing in Node.js ed Express

In Express, imposta l'header prima di res.send():

app.get('/products', async (req, res) => {
  const t0 = performance.now();
  const products = await db.query('SELECT * FROM products WHERE active = 1');
  const t1 = performance.now();
  const html = renderTemplate('product-list', { products });
  const t2 = performance.now();

  res.set('Server-Timing',
    `db;dur=${(t1 - t0).toFixed(1)};desc="Database", tpl;dur=${(t2 - t1).toFixed(1)};desc="Template"`);
  res.send(html);
});

Node invia gli header con il primo res.write(). In una route con streaming, imposta Server-Timing prima della prima scrittura: in seguito, Node lancia ERR_HTTP_HEADERS_SENT.

Come si misura la request duration?

La request duration per i visitatori si ricava dal real-user monitoring (RUM): CoreDash mostra Request nel Phase breakdown della pagina del TTFB, per ciascuna pagina, e la libreria web-vitals riporta requestDuration nella sua attribuzione del TTFB.

Google non prevede una soglia per la request duration; l'avviso Document request latency di Lighthouse segnala risposte del server superiori a 600 ms. Su tutti i caricamenti pagina da smartphone nei 133 siti CoreDash con dati mobile nei 28 giorni fino al 9 novembre 2026, la fase di request si è attestata a 404 ms al 75° percentile.

Nel tuo codice, la libreria web-vitals fornisce anche le voci di Server-Timing ricevute con la pagina:

import { onTTFB } from 'web-vitals/attribution';

onTTFB(({ value, attribution }) => {
  console.log('TTFB', Math.round(value), 'ms');
  console.log('Request duration', Math.round(attribution.requestDuration), 'ms');
  const nav = attribution.navigationEntry;
  if (nav) {
    if (nav.finalResponseHeadersStart) { // Chrome 133 and later
      console.log('Final response headers at', Math.round(nav.finalResponseHeadersStart), 'ms');
    }
    console.table((nav.serverTiming || []).map(({ name, duration }) => ({ name, duration })));
  }
});

Entrambi i valori provengono dalla Navigation Timing API: il TTFB è il responseStart della navigation entry, e web-vitals calcola requestDuration come TTFB meno connectEnd. La lista serverTiming della entry contiene le voci dell'header come oggetti PerformanceServerTiming (l'API Server-Timing nel browser), consentendo a uno script RUM di inviarle a ogni page view.

CoreDash Phase breakdown of Time To First Byte on phones for acme-pagespeed.com: Waiting + Redirect 41 ms, Worker & Cache 4 ms, DNS 6 ms and Connection 88 ms all good, Request 742 ms rated Improve; the page leaves Good during Request.

CoreDash, TTFB su smartphone suddiviso nelle sue cinque parti su acme-pagespeed.com: individua la barra più lunga, in questo caso Request.

I 103 Early Hints fanno apparire la request duration più breve. Chrome calcola un 103 come primo byte, quindi TTFB e request duration terminano all'arrivo dell'hint, mentre il server sta ancora generando la pagina. Vengono inviati da Shopify e anche da Cloudflare se si abilitano gli Early Hints. La proprietà finalResponseHeadersStart della navigation entry o una voce di Server-Timing mostra il tempo server effettivo; 103 Early Hints ne illustra la configurazione.

Un APM, o la metrica http.server.request.duration di OpenTelemetry, misura all'interno dell'applicazione, senza considerare la rete e le code a monte; per questo il RUM mostra una request duration più alta. Un singolo caricamento nei DevTools ("Waiting for server response") è solo un hit o un miss della cache dal tuo computer; i field data registrano invece ogni miss e ogni visitatore distante. Come analizzare e risolvere un TTFB lento mostra come individuare le pagine e i visitatori che registrano una fase di request lenta.

Perché il server è lento a inviare il primo byte?

Sulla maggior parte dei siti un TTFB lento significa che il server rigenera la pagina per ogni visitatore: la cache di pagina manca, o il visitatore la bypassa. Le pagine non cachabili sono lente per il lavoro che svolgono: una query lenta, un'API esterna da attendere, CPU insufficiente.

Cosa noti Causa tipica Dove verificare
Lento su ogni pagina, senza login Cache di pagina assente o miss Header di cache: HIT o MISS
Lento con login o carrello attivo La pagina non è cachabile Server-Timing
Lento sui link da annunci ed email Una query string non presente in cache L'URL con e senza ?gclid=
Lento su ricerca e pagine account Una query lenta o una chiamata esterna Server-Timing, Query Monitor
Veloce nelle vicinanze, lento da lontano Il round trip verso il server RUM per paese
Più lento da un giorno specifico Una release o la cache compromessa Trend della fase di request nel RUM
Lento dopo un'ora di inattività Cache scaduta o cold start Primo caricamento a confronto con il secondo

Come si riduce la request duration?

Parti da una cache di pagina. Una copia archiviata della pagina evita il lavoro del server, e sulla maggior parte dei siti quel lavoro costituisce la quota maggiore di un Time to First Byte (TTFB) lento. Le pagine non cachabili richiedono invece che sia il server stesso a diventare più veloce.

WordPress e WooCommerce

Attiva la cache di pagina in WP Rocket, LiteSpeed Cache o a livello di hosting. Il mio plugin, WP Core Web Vitals, invia la pagina in cache prima del caricamento di WordPress e degli altri plugin: circa cinque volte più veloce rispetto a servirla dall'interno di WordPress.

Verifica il risultato senza autenticazione, in una finestra anonima: utenti loggati, cookie del carrello e query string non gestite dalla cache la bypassano.

Su un'installazione locale di test di WordPress con tema predefinito, la cache di pagina ha portato la fase di request della home page da 31 ms a circa 1 ms (mediana di 15 caricamenti). Un sito reale impiega più tempo a generare una pagina; la copia in cache risponde all'incirca con la stessa rapidità.

Bar chart of the request duration on a local WordPress test install, median of 15 loads each: 31.3 ms with the page cache off and 1.1 ms with the page cache on.

Un'installazione locale non ha latenza di rete, quindi entrambe le barre rappresentano il lavoro del server.

Un sito membership in cui tutti sono autenticati, o un e-commerce in cui quasi tutti i visitatori hanno un carrello, trae scarso beneficio da una cache di pagina: ogni richiesta comporta elaborazione PHP e query al database. Un object cache come Redis mantiene in memoria i risultati frequenti del database; presso molti hosting basta abilitare un'opzione o richiederlo all'assistenza. Query Monitor elenca le query lente e il plugin da cui provengono. Non mostra però il tempo di esecuzione del codice PHP del plugin: un profiler come phpspy individua sia il plugin sia la funzione incriminata.

Shopify

Server, cache e CDN sono di competenza di Shopify. A te spetta il codice Liquid del tema e dei relativi blocchi app, renderizzati da Shopify sui propri server. Shopify Theme Inspector per Chrome mostra quale sezione o snippet richiede troppo tempo: snelliscilo, oppure sostituisci l'app che lo introduce.

Una cache di pagina a monte dell'applicazione

Un reverse proxy, la CDN o una cache che risponde prima dell'avvio del framework evita il lavoro dell'applicazione. Questo header consente alla CDN o al proxy di trattenere l'HTML per dieci minuti e servirlo per un ulteriore minuto mentre recupera una copia aggiornata, imponendo al browser di richiederlo a ogni visita:

Cache-Control: public, max-age=0, s-maxage=600, stale-while-revalidate=60

Non ho impostato il mio plugin per WordPress in modo che serva il file in cache direttamente da nginx o Apache: il guadagno sarebbe stato minimo e ogni controllo su cookie e parametri URL avrebbe dovuto essere replicato nella configurazione del server.

Un Set-Cookie su ogni risposta, per una sessione o un test A/B, spesso impedisce il caching della pagina sulla CDN. Vary: Cookie richiede una copia per ogni valore di cookie: con i cookie di analytics questo azzera quasi del tutto i cache hit. Ogni nuovo valore di gclid o utm_source proveniente da un annuncio crea un nuovo URL, a meno che la cache non ignori tali parametri. Per misurare i tempi del server senza cache, carica la pagina con un parametro non ignorato dalla cache, come ?test= con un valore diverso a ogni richiesta, e verifica che tutti gli header di cache riportino MISS.

Una CDN che memorizza l'HTML

Una CDN che memorizza in cache l'HTML risponde da un server vicino al visitatore, così il Time to First Byte non include più il viaggio verso il server di origine né la sua elaborazione. Una CDN che memorizza solo immagini e script inoltra ogni richiesta HTML al server. Su Cloudflare, l'HTML va in cache solo con una Cache Rule o con APO per WordPress: Configurare Cloudflare per i Core Web Vitals riporta le impostazioni. Il codice all'edge della CDN che ha bisogno del database deve comunque attendere il relativo round trip.

Pagine generate per ciascun visitatore

Pagine con autenticazione, carrello e risultati di ricerca non possono provenire da una cache di pagina; Server-Timing indica il passaggio lento. Per il database: un indice per la query lenta e una sola query per un elenco invece di una per elemento (il pattern N+1). Una pagina che attende un database o un'API in un altro data center aggiunge quel round trip a ogni richiesta: metti in cache la risposta ed esegui in parallelo le chiamate ai servizi non dipendenti tra loro.

const [stock, prices] = await Promise.all([getStock(id), getPrices(id)]);

Invio di email, scrittura dei log e sincronizzazione delle giacenze possono attendere: eseguili dopo la risposta o inseriscili in una coda.

Il server e l'hosting

Passare a un nuovo hosting ha senso quando Server-Timing e i dati RUM mostrano che è il server stesso a essere lento: le pagine in cache sono veloci, mentre su quelle senza cache ogni passaggio richiede troppo tempo. Molti upgrade di piano aggiungono solo spazio disco; un server più veloce ha bisogno di più CPU e memoria. Utilizza una versione recente di PHP con OPcache attivo. Una funzione serverless risente del cold start dopo un periodo di inattività: mantieni un'istanza warm, oppure posiziona una cache di pagina a monte.

TTFB nei framework JavaScript (Next.js, Nuxt, SvelteKit)

Un framework JavaScript che renderizza ogni pagina sul server a ogni richiesta produce il TTFB di una pagina non in cache. Nella pratica ciò accade quando i contenuti del CMS vengono recuperati in tempo reale per ogni richiesta con Cache-Control: private o no-store, impedendo anche alla CDN di memorizzare l'HTML. Renderizza le pagine in modo statico o in cache ovunque i contenuti lo consentano (in Next.js, use cache), metti in cache le chiamate al CMS e lascia che la CDN conservi l'HTML. Invia in streaming i contenuti dinamici dietro <Suspense>, così che la sezione head con i fogli di stile parta per prima. Leggere cookie o header all'interno di un layout costringe ogni pagina sottostante a essere renderizzata a ogni richiesta.

Il server è diventato più veloce per i visitatori reali?

Verifica prima un singolo caricamento, senza login in una finestra anonima, poi con ?gclid= e un valore sempre nuovo. Gli header di risposta dovrebbero mostrare un cache hit (cf-cache-status: HIT su Cloudflare, X-CWV-Cache: HIT con WP Core Web Vitals) e le voci di Server-Timing; un MISS sul caricamento con ?gclid= significa che i visitatori dagli annunci attendono il server. A ogni rilascio occorre invalidare l'HTML anche sulla CDN, altrimenti i visitatori continueranno a ricevere la vecchia pagina.

Il giorno successivo, la voce Request nei dati RUM mostrerà il cambiamento. PageSpeed Insights mostra solo l'intero TTFB aggregato sugli ultimi 28 giorni, quindi si muove lentamente.

Alcune richieste lente richiedono più di una cache o di una configurazione: un negozio in cui ogni visitatore ha un carrello, oppure un hosting o un backend su cui non puoi intervenire. In una Core Web Vitals power hour analizziamo le voci di Server-Timing e le pagine più lente, stabilendo cosa il server deve smettere di fare prima e chi se ne occupa: l'hosting o lo sviluppatore.

About the author

Arjen Karel is a web performance consultant and the creator of CoreDash, a Real User Monitoring platform that tracks Core Web Vitals data across hundreds of sites. He also built the Core Web Vitals Visualizer Chrome extension. He has helped clients achieve passing Core Web Vitals scores on over 925,000 mobile URLs.

Arjen Karel

Ti serve un sito più veloce?

Sono Arjen e da 17 anni sistemo siti lenti. Se hai problemi che non riesci a risolvere da solo, mandami il tuo URL e ne parliamo.

Mandami il tuo URL
Arjen Karel
Arjen Karel, Consulente web performance dal 2009

Perché il fix non funziona?

A volte la CDN serve ancora il vecchio HTML, oppure il fix è finito nel template desktop e il mobile ne usa un altro. Mandami il tuo URL e il problema, e ti rispondo con qualche orario. Prima analizzo i tuoi field data, poi dedichiamo un'ora al tuo sito, ed entro un giorno hai le mie note per iscritto. 350 € IVA esclusa.

Mandami il tuo URL

Non hai uno sviluppatore per il fix? Faccio io il lavoro, su una copia del tuo sito.

Arjen KarelTTFB ancora in rosso su mobile?Mandami il tuo URL