StackPractices
intermediate Por Mathias Paulenko

Checklist de Auditoría de Core Web Vitals

Checklist para auditar Core Web Vitals por página: pasos de optimización de LCP, ajuste de interacciones INP, correcciones de estabilidad visual CLS, análisis de datos de campo vs laboratorio, integración con CrUX y seguimiento de remediación con ejemplos de código para imágenes, fuentes, JavaScript y CSS.

Resumen

Este checklist recorre de punta a punta una auditoría de Core Web Vitals por página: encontrar el elemento LCP y acelerarlo, lograr que las interacciones se sientan instantáneas (INP), evitar que el layout salte (CLS), y reconciliar lo que viven los usuarios reales con lo que reportan las herramientas de laboratorio. Termina con plantillas para el seguimiento de remediación, porque una auditoría que nadie ejecuta es solo un documento.

Google posiciona según el percentil 75 de los datos de campo, así que los objetivos son: LCP ≤ 2,5s, INP ≤ 200ms, CLS ≤ 0,1 en P75 en móvil. Esa elección del P75 importa: la métrica describe a tus usuarios más lentos, no al usuario medio, así que una página que va fina en la conexión de la oficina puede estar suspendiendo para una parte real de la audiencia. Recurre a este checklist cuando audites un sitio existente, o cuando un nuevo tipo de página esté a punto de lanzarse y quieras una línea base antes de que salga.

flowchart diagram: A([Datos de laboratorio<br>Lighthouse / WPT

1. Configuración previa a la auditoría

Antes de tocar ninguna métrica, decide qué tipos de página entran en la auditoría y deja el tooling a punto. Casi nunca auditas todas las URLs de un sitio: empieza por las plantillas que cargan el tráfico y el dinero —home, listado, detalle, checkout— y deja la cola larga para pasadas posteriores. Las herramientas vienen en dos sabores y necesitas ambas: las de laboratorio (Lighthouse, WebPageTest) para diagnosticar causas, y las de campo (CrUX, RUM, Search Console) para saber qué pasó de verdad a los usuarios. Las puntuaciones de laboratorio por sí solas te mienten sobre la experiencia real; los datos de campo por sí solos te dicen que algo va mal, pero nunca por qué.

1.1 Herramientas necesarias

Herramienta             | Propósito                           | Coste
────────────────────────┼─────────────────────────────────────┼──────────
Lighthouse              | Datos de lab, auditorías, consejos  | Gratis
PageSpeed Insights      | Datos de lab + campo combinados     | Gratis
CrUX Dashboard          | Datos de campo de usuarios Chrome   | Gratis
WebPageTest             | Waterfall, filmstrip, análisis      | Gratis/Pago
Chrome DevTools         | Depuración local, panel Performance | Gratis
Librería web-vitals     | Recolección RUM en producción       | Gratis
Search Console          | Informe CWV por URL                 | Gratis

1.2 Plantilla de alcance de la auditoría

URL de página         | Tipo        | Prioridad | Última audit. | Responsable
──────────────────────┼─────────────┼───────────┼───────────────┼──────────
/                     | Homepage    | Alta      | 2026-07-04    | Frontend
/products             | Listado     | Alta      | 2026-07-04    | Frontend
/products/{slug}      | Detalle     | Alta      | Aún no        | Frontend
/blog/{slug}          | Artículo    | Media     | Aún no        | Contenido
/checkout             | Conversión  | Crítica   | 2026-07-04    | Frontend
/search?q={query}     | Búsqueda    | Media     | Aún no        | Frontend
/dashboard            | SPA         | Media     | Aún no        | Frontend

2. Auditoría de LCP (Largest Contentful Paint)

En auditorías reales, el LCP casi siempre es una imagen hero, un titular grande o el póster de un vídeo, y el arreglo rara vez es ingenioso: precarga el elemento, sírvelo más pequeño y evita que otros recursos lo bloqueen. El listón está en 2,5s en P75 en móvil. El checklist de abajo está ordenado para diagnosticar rápido: nombra primero el elemento y luego recorre su ruta de carga hacia atrás hasta encontrar qué lo retiene. Cuando el elemento resulta ser texto, el culpable suele ser una fuente web o una hoja de estilos que bloquea el render, no el texto en sí.

2.1 Checklist de LCP

- [ ] Identifica el elemento LCP de la página
  - Abre Chrome DevTools > Performance > Insights
  - Busca el marcador "LCP" en la línea de tiempo
  - Elementos LCP habituales: imagen hero, texto hero, poster de vídeo

- [ ] Optimiza la carga del elemento LCP
  - Precarga la imagen LCP: <link rel="preload" as="image" href="hero.webp">
  - Usa fetchpriority="high" en la imagen LCP
  - Sirve imágenes responsive con srcset
  - Usa formatos modernos (WebP, AVIF)

- [ ] Optimiza el TTFB (afecta al LCP)
  - Usa CDN para los assets estáticos
  - Cachea el HTML en el edge
  - Optimiza el tiempo de respuesta del servidor (< 600ms)
  - Usa SSR o SSG donde sea posible

- [ ] Elimina los recursos que bloquean el render
  - Inlinea el CSS crítico
  - Difiere el CSS no crítico: <link rel="preload" ... onload="this.rel='stylesheet'">
  - Difiere el JS no crítico: <script defer> o <script type="module">
  - Elimina el CSS sin usar con PurgeCSS o UnCSS

- [ ] Optimiza la carga de fuentes
  - Precarga la fuente principal: <link rel="preload" as="font" type="font/woff2" href="font.woff2" crossorigin>
  - Usa font-display: swap
  - Auto-hospeda las fuentes en vez de Google Fonts CDN
  - Haz subset de las fuentes para reducir el tamaño

2.2 Correcciones de código para LCP

<!-- Precargar la imagen LCP -->
<link rel="preload" as="image" href="/images/hero.webp" fetchpriority="high">

<!-- Imagen LCP responsive -->
<img
  src="/images/hero-800.webp"
  srcset="/images/hero-400.webp 400w, /images/hero-800.webp 800w, /images/hero-1200.webp 1200w"
  sizes="(max-width: 600px) 400px, (max-width: 1200px) 800px, 1200px"
  alt="Imagen hero"
  fetchpriority="high"
  decoding="async"
/>

<!-- Precargar la fuente crítica -->
<link rel="preload" as="font" type="font/woff2"
  href="/fonts/inter-var.woff2" crossorigin>

<!-- CSS crítico inline -->
<style>
  /* Solo estilos above-the-fold */
  body { margin: 0; font-family: 'Inter', sans-serif; }
  .hero { min-height: 50vh; display: flex; align-items: center; }
</style>

<!-- Diferir CSS no crítico -->
<link rel="preload" href="/styles/non-critical.css" as="style"
  onload="this.onload=null;this.rel='stylesheet'">
<noscript><link rel="stylesheet" href="/styles/non-critical.css"></noscript>

3. Auditoría de INP (Interaction to Next Paint)

INP vigila el hueco entre una interacción —un clic, un toque, una tecla— y el momento en que la página pinta la respuesta, y lleva la cuenta de todas las interacciones de la visita, no solo de la primera. Por encima de 200ms en P75 la página suspende, y la causa es casi siempre la misma: JavaScript ocupando el hilo principal justo cuando el usuario intenta hacer algo. Por eso una página puede pintar rápido y seguir sintiéndose rota. Los scripts de terceros merecen sospecha especial aquí —tag managers, widgets de chat, herramientas A/B— porque corren en ese mismo hilo y nadie de tu equipo los controla.

3.1 Checklist de INP

- [ ] Identifica las interacciones lentas
  - Usa Chrome DevTools > Performance > Interactions
  - Busca interacciones > 200ms
  - Interacciones lentas habituales: clics de botón, inputs de formulario, toggles de menú

- [ ] Reduce el tiempo de ejecución de JavaScript
  - Divide tareas largas con setTimeout o scheduler.yield()
  - Usa requestIdleCallback para trabajo no urgente
  - Aplica debounce/throttle a los event handlers
  - Mueve la computación pesada a Web Workers

- [ ] Optimiza los event handlers
  - Usa listeners pasivos: addEventListener('scroll', handler, { passive: true })
  - Evita lecturas síncronas de layout (offsetWidth, getBoundingClientRect) en los handlers
  - Agrupa las actualizaciones del DOM con requestAnimationFrame
  - Usa delegación de eventos en vez de un listener por elemento

- [ ] Reduce el bloqueo del hilo principal
  - Code splitting por ruta
  - Lazy load de componentes pesados
  - Difiere analytics y scripts de terceros
  - Usa Partytown para el JS de terceros en un Web Worker

- [ ] Optimiza el renderizado
  - Usa transform y opacity de CSS para animaciones (aceleradas por GPU)
  - Evita animar propiedades de layout (width, height, top, left)
  - Usa content-visibility: auto para contenido fuera de pantalla
  - Reduce el tamaño del DOM (< 1500 nodos)

3.2 Correcciones de código para INP

// Dividir tareas largas con scheduler.yield()
async function processItems(items) {
  for (const item of items) {
    processItem(item);
    // Ceder el hilo principal periódicamente
    if ('scheduler' in window && 'yield' in scheduler) {
      await scheduler.yield();
    } else {
      await new Promise(resolve => setTimeout(resolve, 0));
    }
  }
}

// Debounce del handler de input
function debounce(fn, delay) {
  let timeoutId;
  return (...args) => {
    clearTimeout(timeoutId);
    timeoutId = setTimeout(() => fn(...args), delay);
  };
}

searchInput.addEventListener('input', debounce(handleSearch, 150));

// Listener de eventos pasivo
document.addEventListener('scroll', handleScroll, { passive: true });

// Agrupar actualizaciones del DOM con requestAnimationFrame
function updateList(items) {
  requestAnimationFrame(() => {
    const fragment = document.createDocumentFragment();
    for (const item of items) {
      const li = document.createElement('li');
      li.textContent = item;
      fragment.appendChild(li);
    }
    listElement.innerHTML = '';
    listElement.appendChild(fragment);
  });
}

// Mover computación pesada a un Web Worker
const worker = new Worker('/js/search-worker.js');
worker.postMessage({ query: 'test' });
worker.onmessage = (e) => {
  renderResults(e.data.results);
};

4. Auditoría de CLS (Cumulative Layout Shift)

El CLS suma cada movimiento inesperado del layout durante la visita, así que una página que salta unos píxeles una docena de veces puede puntuar peor que una que salta una sola vez fuerte. Por encima de 0,1 en P75 es suspenso. Dos culpables explican la mayoría de los CLS malos que he visto: imágenes servidas sin width/height, que dejan al navegador sin poder reservar su espacio, y fuentes web que se intercambian después de que el texto ya se haya renderizado. Justo detrás vienen los banners de cookies y los huecos de anuncios que cargan tarde. Revisa eso antes de meterte en nada más sofisticado.

4.1 Checklist de CLS

- [ ] Reserva espacio para imágenes y embeds
  - Pon atributos width y height en todas las imágenes
  - Usa la propiedad CSS aspect-ratio para imágenes responsive
  - Reserva espacio para anuncios y embeds con min-height

- [ ] Estabiliza la carga de fuentes
  - Usa font-display: swap (causa un pequeño salto)
  - Usa font-display: optional (sin salto si la fuente tarda)
  - Precarga las fuentes para reducir la ventana de swap
  - Iguala las métricas de la fuente de fallback con la web

- [ ] Evita inyectar contenido por encima del contenido existente
  - Los banners y notificaciones deben empujar el contenido, no superponerlo
  - Usa min-height en contenedores de contenido dinámico
  - Carga los anuncios en slots reservados, no insertados dinámicamente

- [ ] Evita animaciones que desplazan el layout
  - Usa transform: translateX/Y para animaciones de deslizamiento
  - Usa opacity para animaciones de fundido
  - No animes width, height, margin ni padding

- [ ] Gestiona el contenido dinámico con elegancia
  - Skeleton screens para los estados de carga
  - min-height en los contenedores de tarjetas
  - Reserva espacio para widgets de terceros

4.2 Correcciones de código para CLS

<!-- Reservar espacio para imágenes con aspect-ratio -->
<img
  src="/images/product.webp"
  width="800"
  height="600"
  style="aspect-ratio: 4 / 3;"
  alt="Imagen de producto"
/>

<!-- Reservar espacio para anuncios -->
<div class="ad-slot" style="min-height: 250px;">
  <!-- El anuncio carga aquí -->
</div>

<!-- Skeleton screen para el estado de carga -->
<div class="card-skeleton" style="min-height: 200px;">
  <div class="skeleton-line"></div>
  <div class="skeleton-line"></div>
  <div class="skeleton-line"></div>
</div>
/* Igualar métricas de la fuente de fallback */
@font-face {
  font-family: 'Inter Fallback';
  src: local('Arial');
  size-adjust: 100%;
  ascent-override: 90%;
  descent-override: 20%;
  line-gap-override: 0%;
}

body {
  font-family: 'Inter', 'Inter Fallback', sans-serif;
}

/* content-visibility para contenido fuera de pantalla */
.long-article-section {
  content-visibility: auto;
  contain-intrinsic-size: 500px;
}

5. Datos de campo vs datos de laboratorio

Los datos de campo son el registro de lo que pasaron los usuarios reales de Chrome en tu página; los de laboratorio son Lighthouse o WebPageTest simulando una sola carga con una conexión limitada. Se contradicen constantemente, y la contradicción en sí es información: cuando el laboratorio sale verde pero el campo está en rojo, tus usuarios están en móviles más lentos, peores redes o interactuando de formas que el script de laboratorio nunca hace. Cuando difieren, gana el campo: es la experiencia que tus usuarios vivieron de verdad, y es el número con el que Google posiciona.

5.1 Comparación de fuentes de datos

Fuente         | Tipo   | Usuarios        | Entorno         | Caso de uso
───────────────┼────────┼─────────────────┼─────────────────┼──────────────────────
CrUX           | Campo  | Chrome real     | Dispositivos    | Seguimiento P75
PageSpeed      | Ambos  | Lab + CrUX      | Simulado        | Chequeo rápido
Lighthouse CI  | Lab    | Ninguno         | Simulado        | Regresiones en CI/CD
RUM (propio)   | Campo  | Todos browsers  | Dispositivos    | Datos cross-browser
Search Console | Campo  | Chrome real     | Dispositivos    | Informe por URL
WebPageTest    | Lab    | Ninguno         | Configurable    | Waterfall en detalle

5.2 Proceso de reconciliación

1. Recoge datos de campo (CrUX, RUM) de la página durante 28 días
2. Recoge datos de laboratorio (Lighthouse) de la misma página
3. Compara las métricas:
   - Si LCP campo > LCP lab: usuarios en dispositivos/redes más lentas
   - Si INP campo > INP lab: usuarios interactúan más que el script de prueba
   - Si CLS campo > CLS lab: contenido dinámico no capturado en lab
4. Investiga las discrepancias:
   - Revisa la distribución de dispositivos en CrUX (móvil vs escritorio)
   - Revisa los tipos de conexión (4G, 3G, WiFi)
   - Revisa las variantes de la página (tests A/B, personalización)
5. Prioriza los arreglos según los datos de campo (impacto real)
6. Verifica los arreglos con datos de laboratorio (testing reproducible)
7. Monitorea los datos de campo tras el despliegue para confirmar la mejora

Haz esta reconciliación antes de priorizar nada. Una página con métricas de laboratorio en verde y de campo en rojo pide investigación por el lado del campo: mezcla de dispositivos, condiciones de red, patrones reales de interacción. Una página que suspende en ambos suele ser la victoria fácil: el laboratorio reproduce el problema de forma fiable, así que puedes iterar arreglos en local y ver cómo aterrizan.


6. Seguimiento de la remediación

La mayoría de los arreglos de CWV son pequeños —una pista de preload, un atributo width, un handler con debounce—, y justo por eso se escapan y nunca llegan a producción. Anota cada uno con un responsable y un número objetivo, o la auditoría se convierte en papel guardado. Algo a tener en cuenta: los datos de campo corren en una ventana móvil de 28 días, así que un arreglo desplegado hoy tarda semanas en reflejarse del todo en CrUX. Apunta la fecha de despliegue junto a cada arreglo y júzgalo por la tendencia, no por la primera lectura tras el release.

6.1 Plantilla de seguimiento de issues

ID  | Página     | Métrica | Actual | Objetivo | Issue                     | Estado     | Responsable
────┼────────────┼─────────┼────────┼──────────┼───────────────────────────┼────────────┼──────────
001 | /          | LCP     | 3.2s   | 2.5s     | Imagen hero sin precargar | Resuelto   | Alicia
002 | /          | CLS     | 0.15   | 0.1      | Swap de fuente causa salto| En curso   | Bruno
003 | /products  | INP     | 280ms  | 200ms    | Handler de búsqueda lento | Abierto    | Carla
004 | /checkout  | LCP     | 2.8s   | 2.5s     | CSS bloqueando el render  | Resuelto   | Alicia
005 | /blog/*    | CLS     | 0.12   | 0.1      | Dimensiones de img ausente| Abierto    | Dani

6.2 Plantilla de informe de auditoría

## Informe de auditoría Core Web Vitals — {URL de la página}

**Fecha:** 2026-07-04
**Auditor:** {Nombre}
**Tipo de página:** {Homepage/Producto/Artículo/etc}

### Datos de campo (CrUX, ventana de 28 días)

| Métrica | P75 | Valoración | Tendencia |
|---------|-----|------------|-----------|
| LCP     | 3.2s| Deficiente | Empeorando |
| INP     | 180ms| Buena     | Estable |
| CLS     | 0.15| Necesita mejora | Estable |

### Datos de laboratorio (Lighthouse)

| Métrica | Valor | Puntuación |
|---------|-------|------------|
| LCP     | 2.9s  | 45         |
| INP     | 150ms | 90         |
| CLS     | 0.12  | 80         |
| TBT     | 300ms | 70         |

### Hallazgos

1. Elemento LCP: imagen hero (1,2MB, sin precargar)
2. Bloqueo de render: 3 archivos CSS, 2 archivos JS
3. Fuente de CLS: swap de fuente en el texto de cabecera
4. INP: el handler del input de búsqueda tarda 280ms

### Plan de remediación

1. Precargar imagen hero y convertir a WebP — Resp.: Alicia, Para: 2026-07-06
2. Inlinear CSS crítico, diferir el resto — Resp.: Alicia, Para: 2026-07-06
3. Precargar fuente, usar font-display: optional — Resp.: Bruno, Para: 2026-07-08
4. Debounce del handler de búsqueda — Resp.: Carla, Para: 2026-07-08

### Impacto esperado

- LCP: 3.2s → 2.3s (precarga + WebP)
- CLS: 0.15 → 0.05 (arreglo de fuente)
- INP: 180ms → 150ms (debounce)

Errores comunes de auditoría

Algunos patrones queman horas de auditoría una y otra vez. El primero es tratar la puntuación de Lighthouse como el veredicto: es un proxy de laboratorio, útil para depurar, no el número que ve Google. El segundo es auditar solo la home mientras las plantillas que cargan el tráfico orgánico —páginas de producto, artículos, checkout— quedan sin tocar. El tercero es cantar victoria demasiado pronto: los datos de campo son una ventana móvil de 28 días, así que una métrica que sigue mal la semana después del arreglo puede estar simplemente purgando la ventana vieja. Y el cuarto es arreglar lo que hace ruido en vez de lo que pesa: una imagen lenta bajo el fold daña menos que un INP de 400ms en la llamada a la acción principal. Deja que los datos de campo, ordenados por prioridad de cada tipo de página, decidan el orden del trabajo.

Ver también

Preguntas frecuentes

¿Cuál es la diferencia entre datos de campo y datos de laboratorio?

Los datos de campo vienen de usuarios reales con sus dispositivos y redes reales. El informe CrUX de Google recoge exactamente eso, directo de Chrome. Los datos de laboratorio son una ejecución simulada en un entorno controlado, de Lighthouse o WebPageTest. Los datos de campo te dicen lo que los usuarios sintieron de verdad, pero van con 28 días de retraso y no pueden probar un cambio antes de publicarlo. Los de laboratorio son inmediatos y reproducibles, pero son una sola suposición sobre un dispositivo y una conexión limitada. Una página puede brillar en el laboratorio y fallar en el campo, así que diagnostica en el lab, mide en el campo, y nunca confíes en una sola corrida de Lighthouse como prueba.

¿Cómo encuentro qué elemento es el elemento LCP?

Graba una carga de página en el panel Performance de DevTools: el marcador "LCP" de la línea de tiempo se sienta justo encima del elemento que lo causó. Lighthouse también lo lista, en "Largest Contentful Paint element", y la librería web-vitals puede registrarlo en producción. Casi siempre es una imagen hero, un encabezado grande o un poster de vídeo. Cuando sepas cuál es, trabaja su ruta de carga: precárgalo, sírvelo en formato moderno y asegúrate de que nada que bloquee el render esté por delante.

¿Por qué mi INP es alto aunque mi página carga rápido?

Al INP no le importa la velocidad de carga; mide con qué rapidez la página contesta a la entrada. Una página puede pintar rápido y aun así sentirse rota, porque JavaScript tiende a acaparar el hilo principal justo cuando el usuario hace clic o teclea. Los sospechosos habituales: event handlers largos, lecturas síncronas del DOM que fuerzan reflow, scripts de terceros ejecutándose en el peor momento, o un bundle tan grande que aún está parseándose cuando el usuario interactúa. La vista Interactions de DevTools muestra qué interacciones son lentas; después divide las tareas largas con scheduler.yield(), aplica debounce a los handlers y empuja el trabajo pesado a un Web Worker. INP reemplazó a FID en marzo de 2024 y cuenta todas las interacciones de la página, no solo la primera.

¿Cómo arreglo el CLS causado por imágenes?

Pon atributos width y height explícitos en cada <img>: el navegador los usa para reservar el espacio antes de que llegue el archivo. Para imágenes responsive añade aspect-ratio como respaldo, y para imágenes que no controlas (subidas de usuarios, slots de anuncios) envuélvelas en un contenedor con min-height o un aspect-ratio fijo. Y el lazy load tampoco es excusa: el espacio tiene que estar ahí antes de que empiece la descarga. La auditoría de CLS de Lighthouse te lista exactamente qué elementos se movieron; con eso, el arreglo suele ser cosa de diez minutos.

¿Con qué frecuencia debería auditar Core Web Vitals?

Una vez al trimestre para cada tipo de página es un buen ritmo de partida. Mantén el monitoreo de campo corriendo en continuo (CrUX o tu propio RUM) con alertas cuando el P75 cruce un umbral, corre Lighthouse CI en cada PR para cazar regresiones en la revisión, y haz una pasada dirigida tras cualquier cosa que toque la ruta crítica: nuevos scripts de terceros, rediseños del hero, upgrades de framework. Si tus métricas llevan un año planas, lo trimestral sobra; si se mueven, aprieta el ciclo.