Salta al contenuto principale

01 - Misurare un sito Angular SSR prima di ottimizzarlo: LCP, CLS e TTFB con Playwright

Sulla home il TTFB mediano è 187 ms e l'LCP 1104 ms; su una pagina articolo l'LCP sale a 2864 ms. Script Playwright, tre tornate e gli intervalli.

Cosa ne pensi di questo articolo?

01 - Misurare un sito Angular SSR prima di ottimizzarlo: LCP, CLS e TTFB con Playwright
Angular Performancefedericocalo.dev

In Breve

Sulla home il TTFB mediano è 187 ms e l'LCP 1104 ms; su una pagina articolo l'LCP sale a 2864 ms. Script Playwright, tre tornate e gli intervalli.

In breve. Se vuoi sapere se il tuo sito Angular è veloce, ti serve un numero che puoi rifare, non una sensazione e non una guida che promette «TTFB sotto il secondo». Questo sito, che è Angular 21 con rendering lato server, non ha nessuna misura di campo: la libreria web-vitals non compare in package.json, quindi nessun visitatore reale ha mai riportato un LCP, un INP o un CLS. Quello che esiste è una misura di laboratorio, che ho fatto l'8 novembre 2026 contro la produzione con Playwright. Sulla home il TTFB mediano è 187 ms e l'LCP 1104 ms. Su una pagina articolo il TTFB resta basso (173 ms) ma l'LCP sale a 2864 ms. Il server risponde in fretta e la pagina compare tardi, quindi il problema non è dove lo cercheresti.

La seconda lezione è la varianza. In un'altra tornata, a pochi minuti di distanza, la stessa pagina articolo ha dato un CLS fino a 0,137 e un LCP mediano di 3496 ms; in una terza, un'ora dopo, un LCP mediano di 2188 ms con valori fra 1488 e 3824. Una misura sola mente. Qui trovi lo script, le tre uscite vere, e l'elenco di ciò che questo metodo non può dirti.

Metodo e limiti. Chromium headless di Playwright 1.59.1 (build chromium_headless_shell-1234), Node.js 24.11.0, emulazione del profilo Pixel 7 (schermo e user agent), nessuna limitazione di rete né di CPU, macchina di sviluppo con fibra, bersaglio la produzione dietro Cloudflare. Il sito misurato è Angular 21.2.14. Sono numeri di laboratorio, utili per confrontare due versioni della stessa pagina, non per dire come va ai tuoi utenti.

Il punto di partenza: che cosa il progetto sa davvero di sé

Prima di scrivere codice di misura conviene chiedersi che cosa è già misurato. La domanda ha una risposta verificabile in un comando:


grep -c "web-vitals" package.json

L'uscita, eseguita nella cartella frontend del repository:


0

Zero occorrenze. Dalla rete si vede che il sito carica Google Tag Manager, Google Analytics e Microsoft Clarity; non ho verificato se e come quegli strumenti riportino gli indicatori, e in ogni caso non sono numeri che io possa rifare con un comando.

Vale anche per i numeri che questo blog ha già pubblicato: l'articolo sui cinque passi verso TTFB sotto il secondo dichiara «Lighthouse 62→96» e «TTFB -67%», e nel repository di oggi non c'è un comando che li rifaccia. La regola che adotto per tutta la serie è che ogni cifra nasce da un comando che puoi ripetere, oppure esce dal testo.

Laboratorio e campo: due domande diverse

Un test di laboratorio carica una pagina, in condizioni che scegli tu, e ti dice cosa è successo quella volta. Una misura di campo raccoglie ciò che è successo ai visitatori reali, con le loro reti e i loro telefoni.

La guida di riferimento di Google, Web Vitals su web.dev, indica come soglie «buone» un LCP entro 2,5 secondi, un INP di 200 millisecondi o meno e un CLS di 0,1 o meno, e consiglia di valutarle al 75° percentile dei caricamenti di pagina, separando mobile e desktop.

Ne escono due conseguenze pratiche. Primo: un valore di laboratorio non è confrontabile con quelle soglie, perché le soglie parlano di un percentile su utenti reali, mentre tu hai cinque caricamenti sul tuo portatile.

Secondo: l'INP non si misura caricando una pagina, perché misura la latenza delle interazioni, e uno script che apre e aspetta non interagisce con nulla. Per questo in questa parte parlo solo di TTFB, LCP, CLS, e tengo l'INP fuori dal perimetro invece di inventarmene un valore.

Lo script: cinque caricamenti, mediana e intervallo

Lo script che segue apre ogni pagina cinque volte, in un contesto pulito a ogni giro (niente cache del giro precedente), registra LCP e CLS con PerformanceObserver e riporta mediana e intervallo, non una media.

L'ho eseguito così com'è; l'unica cosa che dipende dalla mia macchina è CHROME_PATH, che punta al Chromium già installato. Se non lo imposti, executablePath vale undefined e Playwright usa il browser scaricato da npx playwright install.


import { chromium, devices } from 'playwright';

const [base, ...paths] = process.argv.slice(2);
const RUNS = 5;
const mediana = (v) => [...v].sort((a, b) => a - b)[Math.floor(v.length / 2)];

const browser = await chromium.launch({ executablePath: process.env.CHROME_PATH });

for (const path of paths) {
  const righe = [];
  for (let i = 0; i < RUNS; i++) {
    const ctx = await browser.newContext({ ...devices['Pixel 7'] });
    const page = await ctx.newPage();
    await page.addInitScript(() => {
      window.__v = { lcp: 0, cls: 0 };
      new PerformanceObserver((l) => {
        for (const e of l.getEntries()) window.__v.lcp = e.startTime;
      }).observe({ type: 'largest-contentful-paint', buffered: true });
      new PerformanceObserver((l) => {
        for (const e of l.getEntries()) if (!e.hadRecentInput) window.__v.cls += e.value;
      }).observe({ type: 'layout-shift', buffered: true });
    });
    await page.goto(base + path, { waitUntil: 'load' });
    await page.waitForTimeout(4000);
    righe.push(await page.evaluate(() => {
      const nav = performance.getEntriesByType('navigation')[0];
      const fcp = performance.getEntriesByName('first-contentful-paint')[0];
      return { ttfb: nav.responseStart, fcp: fcp ? fcp.startTime : 0, lcp: window.__v.lcp, cls: window.__v.cls };
    }));
    await ctx.close();
  }
  const m = (k) => Math.round(mediana(righe.map((r) => r[k])));
  const intervallo = (k, d = 0) => {
    const v = righe.map((r) => r[k]);
    return `${Math.min(...v).toFixed(d)}-${Math.max(...v).toFixed(d)}`;
  };
  console.log(path);
  console.log(`  TTFB mediana ${m('ttfb')} ms (${intervallo('ttfb')})`);
  console.log(`  LCP  mediana ${m('lcp')} ms (${intervallo('lcp')})`);
  console.log(`  CLS  ${intervallo('cls', 3)}`);
}
await browser.close();

Le scelte che contano, una per una:

  • buffered: true nell'observe: dalla documentazione MDN di PerformanceObserver.observe(), il flag chiede che le voci già emesse vengano messe in coda per l'osservatore. Senza, perderesti le voci già emesse prima che l'osservatore venisse registrato.
  • hadRecentInput: web.dev spiega che gli spostamenti entro 500 ms da un input dell'utente hanno il flag attivo e vanno esclusi dal punteggio. Qui nessuno tocca la pagina, quindi il filtro non cambia il risultato, ma lo lascio perché lo script resta corretto se lo estendi con un clic.
  • LCP come ultima voce emessa: web.dev precisa che ogni voce rappresenta il candidato corrente e che, in generale, il startTime dell'ultima è il valore dell'LCP. «In generale» non è «sempre»: la stessa pagina elenca i casi in cui l'API e la metrica divergono, e io non li ho verificati uno per uno. La specifica W3C è più esplicita: una voce nuova nasce ogni volta che si trova un contenuto più grande del precedente, e l'algoritmo termina al primo evento di scorrimento o di input, perché quelli possono portare contenuto nuovo. Il mio script non scorre e non clicca, quindi l'algoritmo non si ferma prima del tempo.
  • CLS come somma di tutti gli spostamenti: è una semplificazione. La metrica ufficiale prende il «session window» più grande, cioè una raffica di spostamenti con meno di un secondo fra l'uno e l'altro e al massimo cinque secondi di durata. Su quattro secondi di osservazione la somma può solo sovrastimare, mai sottostimare, e quindi è prudente.
  • waitForTimeout(4000): una pausa fissa dopo l'evento load, per lasciare arrivare i contenuti caricati dopo. Tutto ciò che arriva oltre i quattro secondi non lo vedo.

Le cinque voci hanno un criterio comune: ognuna dichiara un'approssimazione che accetto, e la direzione in cui sbaglia. Due vanno distinte dalle altre. buffered: true è l'unica senza la quale il numero sarebbe falso e non solo impreciso: senza quel flag l'osservatore nasce dopo le voci che gli interessano e lo script riporterebbe zero con la stessa faccia con cui riporta 2864. La somma del CLS, invece, sbaglia in una direzione sola, e la sovrastima è il verso prudente di un difetto. La voce che limita tutto il resto in silenzio è l'ultima: i quattro secondi sono il confine del mio campo visivo, e una pagina che si ricompone al quinto secondo per me è stabile.

Che cosa è uscito

Ho lanciato lo script contro la produzione, sulla home e su una pagina articolo di questa stessa serie:


CHROME_PATH=$HOME/.cache/ms-playwright/chromium_headless_shell-1234/chrome-headless-shell-linux64/chrome-headless-shell \
node misura.mjs https://federicocalo.dev /it/ /it/blog/angular-21-ssr-performance-ttfb-core-web-vitals-2026

Uscita del 2026-11-08, circa le 06:41 UTC:


/it/
  TTFB mediana 187 ms (110-426)
  LCP  mediana 1104 ms (1016-2060)
  CLS  0.000-0.000
/it/blog/angular-21-ssr-performance-ttfb-core-web-vitals-2026
  TTFB mediana 173 ms (138-553)
  LCP  mediana 2864 ms (2476-3616)
  CLS  0.000-0.000

Il TTFB è il tempo fra la richiesta e il primo byte della risposta, e qui è simile sulle due pagine: 187 e 173 ms. Se avessi misurato solo quello, la pagina articolo sembrerebbe sana quanto la home.

L'LCP dice altro: 1104 contro 2864 ms. Fra il primo byte e il momento in cui compare l'elemento più grande passano più di due secondi e mezzo, e il rendering lato server non li ha tolti.

Il rendering lato server fa trovare nel documento il contenuto da dipingere, ma non garantisce che venga dipinto presto. Il documento della pagina articolo, chiesto senza compressione, è di 456.548 byte; sul filo arriva molto più piccolo, e quanto dipende da che cosa il client dichiara di accettare:


U=https://federicocalo.dev/it/blog/angular-21-ssr-performance-ttfb-core-web-vitals-2026
for ae in br zstd gzip; do
  printf "%-5s " "$ae"
  curl -s -o /dev/null -D h.txt -H "Accept-Encoding: $ae" -w "%{size_download} byte  " "$U"
  grep -i "^content-encoding" h.txt
done

br    88237 byte  content-encoding: br
zstd  92728 byte  content-encoding: zstd
gzip  97805 byte  content-encoding: gzip

Lo stesso documento costa 86 KB in brotli, 91 in zstd e 96 in gzip: la compressione lo riduce a un cinquantesimo circa dei 456 KB di partenza, e il formato che il tuo browser negozia cambia il risultato di dieci kilobyte. È un numero che va rifatto e non ricordato: fra due richieste a un'ora di distanza il documento è passato da 456.164 a 456.548 byte, perché contiene contatori che cambiano. Scaricarlo, però, è solo il primo dei costi: il browser deve poi interpretare ed eseguire il codice per rendere interattiva la pagina, e quel conto lo apro nella terza parte.

Non ho misurato quale di queste cose pesi di più sull'LCP, e non lo dichiaro: nella parte 3 guardo gli script, e un confronto ripetuto prima e dopo spetta a chi cambia il codice.

Perché una misura sola mente

La prima tornata che ho fatto, pochi minuti prima di quella riportata sopra, usava lo stesso script sulle stesse pagine. Per la pagina articolo ha dato:


/it/blog/angular-21-ssr-performance-ttfb-core-web-vitals-2026 TTFB 160 ms  FCP 2788 ms  LCP 3496 ms  CLS 0.137

Era una versione precedente dello script (stampava il massimo del CLS e non l'intervallo, e riportava anche il FCP), ma sui cinque caricamenti misurava le stesse cose.

LCP mediano di 3496 ms contro i 2864 ms della tornata dopo, e soprattutto un CLS di 0,137 in almeno uno dei cinque caricamenti, che supererebbe la soglia di 0,1, contro 0,000 sempre nella tornata seguente.

Non so spiegare la differenza: potrebbe essere la rete, la cache del bordo di Cloudflare, un contenuto che si carica in ritardo o la macchina occupata da altri processi.

Quello che so è che chi avesse lanciato lo script una volta sola avrebbe pubblicato «CLS 0» oppure «CLS 0,137» con la stessa sicurezza, e in entrambi i casi avrebbe avuto torto a metà.

La terza tornata, un'ora dopo: stesso script, numeri più bassi

Ho rieseguito lo stesso file, senza cambiare una riga, alle 07:39 UTC dello stesso giorno:


/it/
  TTFB mediana 108 ms (90-161)
  LCP  mediana 440 ms (376-544)
  CLS  0.000-0.000
/it/blog/angular-21-ssr-performance-ttfb-core-web-vitals-2026
  TTFB mediana 117 ms (102-397)
  LCP  mediana 2188 ms (1488-3824)
  CLS  0.000-0.000

Sulla home l'LCP mediano scende da 1104 a 440 ms; sulla pagina articolo da 2864 a 2188 ms, con un intervallo che va da 1488 a 3824. Fra il caricamento più rapido e il più lento della stessa pagina, nello stesso quarto d'ora, ci sono 2,3 secondi.

Fra le due tornate non ho toccato il sito. Non posso escludere che qualcun altro abbia pubblicato nel frattempo, né che sia cambiato lo stato della cache al bordo, e proprio per questo non chiamo «miglioramento» la differenza: la chiamo rumore finché non ho un prima e un dopo con una sola variabile in mezzo.

La cosa che non cambia nelle tre tornate è l'ordine: la pagina articolo ha sempre un LCP almeno doppio rispetto alla home - 2,6 volte nella prima tornata (2864 contro 1104 ms), 5 volte nella terza (2188 contro 440) - con un TTFB quasi identico fra le due pagine. Quando un fatto resiste a tre misure incoerenti fra loro, quel fatto puoi usarlo; le singole cifre no.

Un caso minore, dalla mia prima prova a mano: in alcune esecuzioni su quella stessa pagina il contatore degli spostamenti segnalava due eventi con valore arrotondato a zero. Lo scrivo perché è il tipo di dettaglio che un grafico di sola mediana nasconde: la stabilità visiva non è un numero fisso della pagina, è una distribuzione.

Come rendere la misura utile nel tempo

Uno script che dà un numero una volta serve a poco: serve quando lo confronti con sé stesso. L'abitudine che userò nelle parti successive ha un ordine preciso, ed è per questo che la scrivo in prosa. Prima misuri e salvi l'uscita, con la data e il commit. Poi cambi una cosa sola.

Poi ripeti con lo stesso comando, sulla stessa macchina e a carico simile, e confronti le mediane guardando se gli intervalli si sovrappongono: se sì, non hai misurato un miglioramento ma il rumore.

Infine scrivi cosa non hai misurato, a partire dall'INP. Invertire i primi due passi, cioè cambiare e poi misurare, è l'errore più comune, e lascia senza un punto di confronto.

Se invece vuoi i dati di campo, la strada documentata da web.dev è la libreria web-vitals, che riporta le metriche dal browser dei visitatori a un endpoint tuo; su questo blog il percorso è descritto in come misurare e monitorare i Core Web Vitals in produzione. In questo repository non è installata, e installarla porta con sé decisioni (dove mandare i dati, il consenso, quanto conservarli) che non spettano a un articolo.

Adesso sai fare questo

Sai dire in un comando se il tuo progetto ha misure di campo, sai misurare TTFB, LCP e CLS di una pagina Angular SSR con Playwright senza dipendenze nuove, sai riportare mediana e intervallo invece di un numero solo, e sai distinguere un TTFB basso da una pagina che compare presto.

Nella parte 2 uso lo stesso strumento per un difetto diverso, trovato su questo stesso sito: una pagina che a 320 pixel scorre di lato, con due colpevoli impilati uno sull'altro. Nella parte 3 passo dal layout al codice e conto quanti file JavaScript scarica davvero una pagina.

Fonti

  • Web Vitals, web.dev - soglie di LCP, INP e CLS e raccomandazione del 75° percentile, consultata il 2026-11-08
  • Largest Contentful Paint, web.dev - le voci largest-contentful-paint come candidati e l'ultima come valore, consultata il 2026-11-08
  • Cumulative Layout Shift, web.dev - hadRecentInput e definizione di session window, consultata il 2026-11-08
  • PerformanceObserver.observe(), MDN - il parametro buffered, consultata il 2026-11-08
  • Largest Contentful Paint, specifica W3C - §1.1: una voce nuova per ogni contenuto più grande, algoritmo che termina al primo scorrimento o input, e l'avvertenza sulle pagine caricate fuori schermo, consultata il 2026-11-08
  • Misura nel repository: grep -c "web-vitals" package.json in frontend/, eseguito il 2026-11-08 (Angular 21.2.14 installato, verificato con node -p "require('@angular/core/package.json').version")
  • Misura sulla produzione: node misura.mjs come sopra, Playwright 1.59.1, tre tornate il 2026-11-08 (circa 06:41, 06:45 e 07:39 UTC)
  • Peso del documento: il ciclo con curl -H "Accept-Encoding: …" riportato sopra, eseguito il 2026-11-08 alle 07:46 UTC

Le prime quattro voci e la quinta rispondono a due domande diverse, e vale la pena non confonderle. Le pagine di web.dev e la specifica W3C dicono che cosa sia una metrica e dove stia la sua soglia: su quelle non ho nulla da aggiungere. I numeri di questo articolo, invece, non vengono da nessuna di loro: vengono dai comandi delle ultime tre voci, eseguiti su una macchina sola, in un pomeriggio solo. Se devi fidarti di una cosa qui dentro, fidati degli script: sono l'unica parte che puoi rieseguire per vedere se mento.

Commenti

Caricamento commenti...

Accedi per commentare

Articoli e strumenti nuovi anche su Telegram

Il canale Telegram segnala gli articoli e gli strumenti nuovi del sito.

Ti è piaciuto questo articolo?

Esplora altri contenuti sul blog o scopri i miei progetti