Core Web Vitals: qué miden LCP, INP y CLS y cómo mejorarlas
Las Core Web Vitals miden tres cosas que el usuario nota: cuánto tarda en aparecer el contenido, cuánto tarda la página en responder y cuánto se mueve. Te explico cada métrica, sus umbrales, cómo medirlas y qué arreglar primero.
- Javi Mata
- 10 min de lectura
Tabla de contenido
- Qué son las Core Web Vitals
- LCP: cuánto tarda en aparecer lo importante
- Las cuatro partes del LCP
- Qué arreglar
- INP: cuánto tarda la página en responder
- Qué arreglar
- CLS: cuánto se mueve la página
- Qué arreglar
- Cómo medirlas: campo y laboratorio
- Medir con la librería web-vitals
- Mi recomendación
- Conclusión
- Fuentes
En 2020 escribí 10 consejos para darle velocidad a tu sitio. Siguen siendo buenos consejos, pero hoy hay una forma más precisa de saber si un sitio “se siente rápido”: las Core Web Vitals, tres métricas que Google define y documenta en web.dev. En este artículo te explico qué mide cada una, cuándo se considera buena y qué suele arreglarla.
Qué son las Core Web Vitals
Web Vitals es una iniciativa de Google para dar una guía unificada sobre las señales de calidad que importan para la experiencia de usuario. Las Core Web Vitals son el subconjunto que aplica a todas las páginas web, que todo dueño de un sitio debería medir y que aparece en todas las herramientas de Google.
El conjunto actual cubre tres aspectos de la experiencia: carga, interactividad y estabilidad visual.
| Métrica | Qué mide | Bueno | Necesita mejorar | Pobre |
|---|---|---|---|---|
| LCP (Largest Contentful Paint) | Carga | 2.5 s o menos | Entre 2.5 s y 4 s | Más de 4 s |
| INP (Interaction to Next Paint) | Interactividad | 200 ms o menos | Entre 200 ms y 500 ms | Más de 500 ms |
| CLS (Cumulative Layout Shift) | Estabilidad visual | 0.1 o menos | Entre 0.1 y 0.25 | Más de 0.25 |
Dos detalles de la documentación que cambian cómo se leen esos números:
- Se miden en el percentil 75 de las cargas de página, separando móvil y escritorio. No basta con que tu prueba salga bien: tiene que salir bien para la mayoría de tus usuarios.
- Una página pasa si cumple las tres en ese percentil 75.
Las métricas tampoco son eternas. Pasan por un ciclo de vida (experimental, pendiente y estable), y las estables no cambian más de una vez al año. El ejemplo más claro: INP sustituyó a FID (First Input Delay) como Core Web Vital estable en 2024. Si todavía ves FID en algún reporte o tutorial, está desactualizado.
LCP: cuánto tarda en aparecer lo importante
LCP reporta el tiempo de renderizado de la imagen, el bloque de texto o el video más grande visible en la pantalla, contado desde que el usuario empezó a navegar a la página. Los elementos que cuentan son, entre otros, <img>, <image> dentro de un <svg>, <video>, elementos con una imagen de fondo cargada con url() y elementos de bloque que contienen texto.
Un detalle importante: LCP incluye el tiempo de redirecciones, de conexión y demás retrasos hasta el primer byte, por eso puede salir distinto en campo que en laboratorio.
Las cuatro partes del LCP
La guía de optimización divide el LCP en cuatro partes que, sumadas, dan el tiempo total:
- TTFB (Time to First Byte): desde que empieza la carga hasta que llega el primer byte del HTML.
- Retraso de carga del recurso: desde el TTFB hasta que el navegador empieza a descargar el recurso del LCP (por ejemplo, la imagen principal).
- Duración de carga del recurso: lo que tarda en descargarse ese recurso.
- Retraso de renderizado del elemento: desde que termina de descargarse hasta que el elemento se pinta.
Las dos que llevan “retraso” en el nombre deberían acercarse a cero. Como guía (no regla estricta), web.dev propone que el TTFB y la duración de carga sean cerca del 40 % cada uno, y cada retraso menos del 10 %.
Qué arreglar
- Que la imagen principal se pueda descubrir en el HTML. Si el
<img>lo inserta JavaScript, o si una librería de lazy load esconde la ruta endata-src, el navegador no la encuentra hasta ejecutar ese código. Si la imagen solo aparece en un CSS, precárgala:
<!-- Load the stylesheet that will reference the LCP image. -->
<link rel="stylesheet" href="/path/to/styles.css">
<!-- Preload the LCP image with a high fetchpriority so it starts loading with the stylesheet. -->
<link rel="preload" fetchpriority="high" as="image" href="/path/to/hero-image.webp" type="image/webp">
- Nunca hagas lazy load de la imagen del LCP. La documentación lo dice tal cual: siempre añade retraso. Esto aplica a la técnica que expliqué en lazy load con IntersectionObserver: úsala para las imágenes de más abajo, nunca para la principal.
- Dale prioridad. Si una imagen probablemente será el elemento LCP, márcala con
fetchpriority="high"; ponerlo en más de una o dos imágenes deja de servir:
<img fetchpriority="high" src="/path/to/hero-image.webp">
- Quita lo que bloquea el renderizado. Hojas de estilo enormes o scripts síncronos en el
<head>pueden impedir que el elemento se pinte aunque la imagen ya haya llegado. Reduce el CSS (o inclúyelo en línea si es pequeño) y difiere el JavaScript que no sea crítico. - Reduce el peso y la distancia. Imágenes del tamaño correcto, formatos modernos como AVIF o WebP, compresión, un CDN y una buena política de caché.
- Cuida el TTFB. Una causa común de un TTFB lento son las redirecciones múltiples, por ejemplo desde anuncios o enlaces acortados.
INP: cuánto tarda la página en responder
INP observa la latencia de todos los clics, toques y pulsaciones de teclado durante la visita y reporta, en la mayoría de los sitios, la interacción más lenta (en páginas con muchas interacciones ignora la más alta por cada 50). Desplazarse, pasar el cursor o hacer zoom no cuentan.
La latencia de una interacción tiene tres partes:
- Retraso de entrada: desde que el usuario interactúa hasta que empiezan a correr los manejadores de eventos. Suele crecer cuando el hilo principal está ocupado, por ejemplo evaluando scripts mientras la página carga.
- Duración del procesamiento: lo que tardan en ejecutarse esos manejadores.
- Retraso de presentación: desde que terminan los manejadores hasta que el navegador pinta el siguiente frame.
Una página puede no tener INP: si nadie hizo clic, tocó ni tecleó, o si la visitó un bot que no interactúa.
Qué arreglar
- Haz poco trabajo en los manejadores y cede el hilo principal. Partir el trabajo en tareas separadas evita tareas largas que bloquean otras interacciones.
setTimeoutes una forma de hacerlo, porque su callback corre en una tarea nueva. - Actualiza primero lo visible y deja lo demás para después. Este es el ejemplo de la documentación con un editor de texto: actualiza el cuadro de texto de inmediato y difiere el conteo de palabras, la ortografía y el guardado:
textBox.addEventListener('input', (inputEvent) => {
// Update the UI immediately, so the changes the user made
// are visible as soon as the next frame is presented.
updateTextBox(inputEvent);
// Use `setTimeout` to defer all other work until at least the next
// frame by queuing a task in a `requestAnimationFrame()` callback.
requestAnimationFrame(() => {
setTimeout(() => {
const text = textBox.textContent;
updateWordCount(text);
checkSpelling(text);
saveChanges(text);
}, 0);
});
});
- Evita el layout thrashing: cambiar estilos con JavaScript y leerlos en la misma tarea obliga al navegador a calcular el layout de forma síncrona.
- Mantén el DOM pequeño. Un DOM muy grande encarece el renderizado, tanto al cargar como al responder a una interacción.
CLS: cuánto se mueve la página
CLS mide la mayor ráfaga de desplazamientos inesperados del layout durante toda la vida de la página. Una ráfaga (o “ventana de sesión”) agrupa desplazamientos que ocurren con menos de 1 segundo entre ellos, con un máximo de 5 segundos en total.
No todos los movimientos cuentan: los que ocurren dentro de los 500 ms posteriores a un clic, toque o tecla se excluyen, porque el usuario los espera.
Qué arreglar
- Pon
widthyheighta tus imágenes y videos. Los navegadores calculan la proporción a partir de esos atributos y reservan el espacio antes de que la imagen cargue. Con este CSS la imagen sigue siendo responsiva:
<!-- set a 640:360 i.e a 16:9 aspect ratio -->
<img src="puppy.jpg" width="640" height="360" alt="Puppy with balloons">
img {
height: auto;
width: 100%;
}
- Reserva espacio para lo que carga tarde. Anuncios, embeds e iframes son de los mayores culpables. Usa
min-heightoaspect-ratioen el contenedor, y no colapses el espacio si al final no llega nada. - No insertes contenido sin que el usuario lo pida. Banners o formularios que aparecen arriba empujan todo lo demás. Reserva su espacio, superponlos al contenido o, para listas que crecen, usa un botón de “Cargar más”.
- Anima con
transform. Cambiartopoleftprovoca desplazamientos;transform: translate()ytransform: scale()no. - Controla las fuentes web.
font-display: optionalevita el re-layout, define siempre una fuente de respaldo (por ejemplofont-family: "Google Sans", sans-serif;) y precarga las fuentes críticas con<link rel=preload>. - Que tus páginas sean elegibles para la bfcache. La caché de ida y vuelta restaura la página tal como la dejaste al usar Atrás o Adelante, sin repetir los desplazamientos de la carga.
Cómo medirlas: campo y laboratorio
Hay dos tipos de datos y conviene no confundirlos:
- Datos de campo: vienen de usuarios reales. El Chrome User Experience Report (CrUX) recoge datos anónimos de cada Core Web Vital y alimenta PageSpeed Insights, el informe de Core Web Vitals de Search Console y Chrome DevTools.
- Datos de laboratorio: una prueba controlada, útil durante el desarrollo y para detectar regresiones antes de publicar. Lighthouse mide LCP y CLS, pero no puede medir INP porque no hay un usuario interactuando; en su lugar usa TBT (Total Blocking Time) como aproximación.
La documentación es clara en que el laboratorio no sustituye al campo: el rendimiento real depende del dispositivo, la red y cómo interactúa cada persona. Además, los datos de CrUX no dan el detalle por visita que necesitas para diagnosticar, así que Google recomienda montar tu propia medición con usuarios reales.
Medir con la librería web-vitals
La forma más sencilla de hacerlo es la librería web-vitals de Google, que mide cada métrica igual que las herramientas de Google. Este es el ejemplo oficial, que envía cada métrica a un endpoint tuyo:
import {onCLS, onINP, onLCP} from 'web-vitals';
function sendToAnalytics(metric) {
const body = JSON.stringify(metric);
// Use `navigator.sendBeacon()` if available, falling back to `fetch()`.
(navigator.sendBeacon && navigator.sendBeacon('/analytics', body)) ||
fetch('/analytics', {body, method: 'POST', keepalive: true});
}
onCLS(sendToAnalytics);
onINP(sendToAnalytics);
onLCP(sendToAnalytics);
Después solo tienes que agregar esos datos y comprobar si al menos el 75 % de las visitas cumplen los umbrales.
Mi recomendación
- Empieza por los datos de campo en PageSpeed Insights o Search Console. Si tu sitio no tiene suficiente tráfico para aparecer en CrUX, mide con
web-vitals. - Ataca la métrica que falla, no la que es más fácil. Un 100 en Lighthouse no garantiza un buen INP en el teléfono de tus usuarios.
- En LCP, revisa primero la imagen principal: que esté en el HTML, sin lazy load y con
fetchpriority="high". Son cambios pequeños en el HTML y la propia guía ordena sus recomendaciones empezando por las de mayor impacto probable, con el retraso de carga del recurso en primer lugar. - En CLS, revisa dimensiones de imágenes y banners antes que cualquier otra cosa.
Conclusión
Las Core Web Vitals traducen “mi sitio se siente lento” en tres números con umbrales claros: LCP para la carga, INP para la respuesta y CLS para la estabilidad. Mide con usuarios reales, identifica cuál de las tres falla y aplica los arreglos de su guía; muchos son cambios pequeños en el HTML y el CSS.
Fuentes
Etiquetas:
Compartir: