
Monitoreo de Core Web Vitals con usuarios reales: tu pipeline RUM
Lighthouse te dice cómo se comporta una página en una sola máquina, una sola vez. Tus usuarios tienen teléfonos más lentos, peores redes y scripts de terceros que cargan tarde. El monitoreo de Core Web Vitals con usuarios reales (RUM, por real user monitoring) cierra esa brecha: mide LCP, INP y CLS en los navegadores de los visitantes reales y envía los datos a un backend que tú controlas. Esta guía trata del diseño de ese sistema: el recolector en el cliente, el payload, el endpoint de ingesta, el modelo de datos, las consultas de agregación y las alertas, con los trade-offs de cada paso.
Si lo que buscas es el trabajo de optimización en sí (imágenes, caché, scripts, fuentes), empieza por nuestra guía sobre cómo mejorar la velocidad de un sitio web en 9 pasos. Este artículo trata de saber, con evidencia, qué correcciones importan para tu tráfico real y si un deploy empeoró las cosas.
Por qué construir RUM si ya existe CrUX
El Chrome UX Report (CrUX) de Google es gratuito y se basa en usuarios reales de Chrome, pero tiene dos límites que importan a un equipo de ingeniería. Primero, los valores de la API de CrUX se calculan sobre los 28 días anteriores como ventana móvil, así que una regresión publicada hoy aparece poco a poco y una corrección tarda semanas en notarse. Segundo, solo conoce URLs y orígenes: no puede decirte qué release, qué plantilla de página, qué variante de un A/B test ni qué elemento del DOM causó el problema.
Tus opciones, a grandes rasgos:
- Solo CrUX. Cero costo de construcción, sin detalle por release ni por elemento, retroalimentación lenta.
- Un producto RUM comercial. Rápido de adoptar, buenos dashboards; pagas por volumen y aceptas su modelo de datos y su retención.
- Tu propio pipeline. Más trabajo, pero eliges las dimensiones (release, plantilla de ruta, tenant, experimento), conservas los datos crudos y puedes cruzarlos con eventos de negocio como la finalización de una compra.
Construir el tuyo tiene sentido si despliegas seguido, necesitas datos por tenant o por cliente, o debes mantener los datos en tu propia infraestructura.
Las metas contra las que mides
Ten claras las definiciones antes de diseñar el almacenamiento. INP reemplazó a First Input Delay como Core Web Vital el 12 de marzo de 2024, así que un pipeline actual recolecta LCP, INP y CLS (más TTFB como diagnóstico). Los umbrales de "bueno" son LCP de 2.5 s o menos, INP por debajo de 200 ms y CLS por debajo de 0.1, evaluados en el percentil 75 y por separado para teléfonos y escritorio. Google explica que eligió el percentil 75 en parte porque es menos sensible a los valores atípicos.
En consecuencia: agrega con percentiles, no con promedios, y haz del tipo de dispositivo una dimensión de primer nivel.
Monitoreo de Core Web Vitals con usuarios reales: la arquitectura
Un pipeline RUM tiene cinco partes:
- Recolector en la página: mide las métricas y su atribución, y las agrupa en lotes.
- Endpoint de beacons: acepta POSTs pequeños y no confiables, los valida y responde rápido.
- Buffer: una cola o un lote en memoria para que la ingesta nunca se bloquee esperando a la base de datos.
- Almacén: una fila por métrica por vista de página, con upsert por ID de métrica.
- Agregación y alertas: p75 por ruta, dispositivo y release, con tamaños mínimos de muestra.
Empieza simple: un servicio pequeño que escribe en Postgres; cambia el buffer y el almacén más adelante si el volumen lo exige.
Paso 1: el recolector en el cliente
No escribas tú la lógica de las métricas; INP y CLS tienen casos límite (back/forward cache, prerenderizado, pestañas en segundo plano) que la librería web-vitals de Google ya resuelve. Usa su build de atribución, que agrega a cada métrica un objeto attribution con datos de diagnóstico y se importa desde web-vitals/attribution en lugar de web-vitals. Las versiones recientes también exponen el elemento objetivo en la atribución de INP.
import {onCLS, onINP, onLCP, onTTFB} from 'web-vitals/attribution';
const ENDPOINT = '/rum';
const SAMPLE_RATE = Number(window.__RUM_SAMPLE_RATE__ ?? 1);
// Muestrea por sesión, no por vista de página: el usuario está dentro o fuera.
function inSample() {
let flag = sessionStorage.getItem('rum');
if (flag === null) {
flag = Math.random() < SAMPLE_RATE ? '1' : '0';
sessionStorage.setItem('rum', flag);
}
return flag === '1';
}
const pending = new Map(); // llave metric.id: solo se guarda el valor más reciente
function summarize({name, attribution: a = {}}) {
switch (name) {
case 'LCP': return {target: a.target, ttfb: a.timeToFirstByte,
loadDelay: a.resourceLoadDelay, loadDuration: a.resourceLoadDuration,
renderDelay: a.elementRenderDelay};
case 'INP': return {target: a.interactionTarget, type: a.interactionType,
inputDelay: a.inputDelay, processing: a.processingDuration,
presentation: a.presentationDelay};
case 'CLS': return {target: a.largestShiftTarget};
default: return {};
}
}
function enqueue(metric) {
pending.set(metric.id, {
id: metric.id, name: metric.name, value: metric.value,
rating: metric.rating, nav: metric.navigationType,
attr: summarize(metric),
});
}
function flush() {
if (pending.size === 0) return;
const body = JSON.stringify({
route: window.__ROUTE__, // plantilla, p. ej. "/product/:slug"
release: window.__RELEASE__, // SHA de git o número de build
ect: navigator.connection?.effectiveType ?? null,
metrics: [...pending.values()],
});
pending.clear();
const ok = navigator.sendBeacon?.(ENDPOINT, body);
if (!ok) fetch(ENDPOINT, {method: 'POST', body, keepalive: true});
}
if (inSample()) {
onLCP(enqueue); onINP(enqueue); onCLS(enqueue); onTTFB(enqueue);
addEventListener('visibilitychange', () => {
if (document.visibilityState === 'hidden') flush();
});
}
Notas de diseño:
- Envía al cambiar
visibilitychangea hidden, no enunload. Ese es el último momento en que puedes enviar datos de forma confiable en móvil, y INP y CLS siguen cambiando hasta entonces. - La misma métrica puede reportarse más de una vez. Si el usuario vuelve a la pestaña e interactúa de nuevo, el INP de esa misma vista de página recibe un valor nuevo con el mismo
id. Los propios ejemplos de la librería envían elidjustamente para poder agregar los eventos por vista de página. Tu backend debe trataridcomo llave de upsert. - Envía un cuerpo de texto a una ruta propia (first-party). Un cuerpo string sale como
text/plain(sin preflight de CORS), y las rutas del mismo dominio tienen menos probabilidad de ser bloqueadas. - Envía la plantilla de ruta, no la URL cruda.
/product/:slugse agrega bien;/product/blue-shirt-xl?utm_source=…dispara la cardinalidad y puede filtrar datos personales en los query strings. - Mantén la atribución pequeña: selectores y algunos números, no entradas de performance completas.
El build de atribución es un poco más pesado que el estándar, así que carga el recolector fuera de la ruta crítica, por ejemplo con un import() dinámico cuando la página ya sea interactiva.
Paso 2: el endpoint de beacons
Trata cada beacon como entrada hostil y haz lo mínimo posible de forma síncrona.
// Pseudocódigo estilo Express
app.post('/rum', express.text({type: '*/*', limit: '16kb'}), (req, res) => {
res.status(204).end(); // responde primero, nunca hagas esperar a la página
let p;
try { p = JSON.parse(req.body); } catch { return; }
if (!Array.isArray(p.metrics) || p.metrics.length > 10) return;
if (isBot(req.get('user-agent'))) return;
const route = KNOWN_ROUTES.has(p.route) ? p.route : 'other';
const device = deviceClass(req.get('user-agent')); // 'mobile' | 'desktop' | 'tablet'
const country = req.get('cf-ipcountry') ?? null; // header geo del CDN; nunca guardes la IP
for (const m of p.metrics) {
if (!ALLOWED.has(m.name)) continue;
if (typeof m.value !== 'number' || m.value < 0 || m.value > MAX[m.name]) continue;
buffer.push({
metric_id: String(m.id).slice(0, 64), name: m.name, value: m.value,
rating: m.rating, nav: m.nav, route, device, country,
release: String(p.release ?? '').slice(0, 40),
attr: truncateStrings(m.attr, 200),
});
}
});
setInterval(() => writeBatch(buffer.splice(0)), 5000); // inserciones en lote
Decisiones clave:
- Usa listas permitidas de rutas y nombres de métricas. Todo lo demás pasa a
othero se descarta. Es tu principal defensa contra la explosión de cardinalidad y los datos basura. - Pon un tope por métrica (
MAX) con un límite que tú elijas; los valores por encima suelen venir de relojes rotos o pestañas olvidadas. - Calcula el tipo de dispositivo y el país en el servidor. No confíes en el cliente para dimensiones que puedes calcular tú, y evita guardar direcciones IP.
- Limita la tasa de peticiones en el edge: un endpoint RUM es una API de escritura abierta.
- Escribe en lotes. Con más volumen, reemplaza el buffer en memoria por una cola (SQS, Pub/Sub, Kafka, Redis Streams) para que un incidente de la base de datos no tumbe el servicio.
Paso 3: el modelo de datos
Guarda una fila por métrica por vista de página. Mantenla angosta y fácil de anexar.
CREATE TABLE rum_metric (
metric_id text PRIMARY KEY, -- id de web-vitals, único por vista de página + métrica
received_at timestamptz NOT NULL DEFAULT now(),
name text NOT NULL, -- LCP | INP | CLS | TTFB
value double precision NOT NULL,
rating text, -- good | needs-improvement | poor
nav text, -- navigate | reload | back-forward-cache | prerender ...
route text NOT NULL,
device text NOT NULL,
country text,
release text,
attr jsonb
);
CREATE INDEX ON rum_metric (name, received_at);
-- Upsert: los reportes posteriores de la misma vista reemplazan a los anteriores
INSERT INTO rum_metric (metric_id, name, value, rating, nav, route, device, country, release, attr)
VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10)
ON CONFLICT (metric_id) DO UPDATE
SET value = EXCLUDED.value, rating = EXCLUDED.rating,
attr = EXCLUDED.attr, received_at = EXCLUDED.received_at;
Trade-offs de almacenamiento:
- Postgres con filas crudas es lo más simple y es exacto. Particiona por día y elimina particiones viejas para controlar la retención.
- Un almacén columnar (ClickHouse, BigQuery) maneja volúmenes mucho mayores y trae funciones de cuantiles integradas, a cambio de operar otro sistema. Los almacenes columnares suelen preferir inserciones a upserts; ahí insertas cada reporte y te quedas con el más reciente por
metric_idal consultar (por ejemplo conargMaxen ClickHouse). - Histogramas preagregados (buckets fijos por métrica, ruta, dispositivo y hora) ocupan muy poco y se combinan barato, pero los percentiles pasan a ser aproximados y pierdes la atribución por elemento. Un híbrido común: histogramas para tendencias de largo plazo y filas crudas con retención corta para depurar.
Paso 4: consultas de agregación que coinciden con cómo te evalúa Google
Calcula el p75 por métrica, por tipo de dispositivo y por ruta, con un tamaño mínimo de muestra para que los grupos pequeños no generen ruido.
SELECT route, device,
count(*) AS samples,
percentile_cont(0.75) WITHIN GROUP (ORDER BY value) AS p75
FROM rum_metric
WHERE name = 'INP'
AND received_at > now() - interval '7 days'
GROUP BY route, device
HAVING count(*) >= :min_samples
ORDER BY p75 DESC;
Para encontrar qué corregir, agrupa por atribución en lugar de por ruta:
SELECT attr->>'target' AS element,
count(*) AS poor_interactions,
avg((attr->>'processing')::float) AS avg_processing_ms
FROM rum_metric
WHERE name = 'INP' AND rating = 'poor'
AND received_at > now() - interval '7 days'
GROUP BY 1
ORDER BY poor_interactions DESC
LIMIT 20;
Las subpartes de INP te dicen dónde se fue el tiempo: un input delay largo apunta a trabajo que ya estaba ocupando el hilo principal (a menudo scripts de terceros), un processing largo apunta a tus manejadores de eventos y un presentation delay largo apunta al costo de renderizado después del manejador. En LCP, comparar TTFB, resource load delay, load duration y render delay te dice si mirar el servidor, el descubrimiento de la imagen principal, su tamaño o el código que bloquea el renderizado. Si necesitas nombrar el script culpable, el build de atribución también puede exponer datos de Long Animation Frames, que solo reporta entradas de script de más de 5 ms.
Paso 5: alertas que entienden los releases
Tener tu propio pipeline te permite detectar regresiones en horas, no en semanas. Cada fila lleva release, así que compara el build nuevo con el anterior:
para cada (ruta, dispositivo, métrica) con muestras >= min_samples en ambos releases:
delta = p75(new_release) - p75(previous_release)
si delta > tolerancia[métrica] y p75(new_release) cruza el umbral de "bueno":
alertar(responsable_de(ruta), ruta, dispositivo, métrica, principales elementos de la atribución)
Compara peras con peras (mismas rutas, mismo tipo de dispositivo y ventanas de tiempo comparables) e incluye los principales elementos de la atribución para que quien esté de guardia empiece desde un selector, no desde un dashboard.
Errores comunes
- Promediar en lugar de usar percentiles. La media esconde la cola lenta que el percentil 75 está diseñado para capturar.
- Mezclar móvil y escritorio en un solo número, lo que esconde los problemas de móvil detrás de escritorios rápidos.
- URLs crudas como dimensión. Cardinalidad sin límite, consultas lentas y datos personales en los query strings.
- Insertar cada reporte como una vista de página nueva. Sin upsert por
id, las vistas con varias actualizaciones de INP se cuentan más de una vez. - Enviar en
unloado una sola vez al cargar, lo que pierde las actualizaciones tardías de INP y CLS. - Cargar el recolector bloqueando el renderizado, con lo que la medición se vuelve la regresión.
- Alertar sin muestras mínimas, lo que entrena al equipo a ignorar las alertas.
Checklist de implementación
- Build de atribución de web-vitals cargado fuera de la ruta crítica
- Muestreo por sesión con una tasa configurable
- Plantilla de ruta e ID de release inyectados en build o en render
- Envío en
visibilitychangea hidden consendBeacony respaldo conkeepalive - Endpoint propio que responde 204 de inmediato
- Listas permitidas, topes de valores y límites de tamaño; dimensiones calculadas en el servidor; sin guardar IPs
- Upsert (o el más reciente por ID al consultar) con llave en el ID de métrica
- Consultas de p75 por métrica, ruta y dispositivo con tamaño mínimo de muestra
- Alertas por comparación de releases que incluyen los principales elementos de la atribución
- Política de retención y una lista documentada de los campos recolectados
Cuando el pipeline vive dentro de un producto más grande, como una tienda multi-tenant o un portal de clientes, diséñalo junto con el resto de tu stack de observabilidad; es el tipo de trabajo que hacemos en desarrollo de software a la medida. Para sitios de marketing, los mismos principios aplican en nuestros proyectos de diseño y desarrollo de páginas web.
Preguntas frecuentes
¿Mis números de RUM coincidirán exactamente con CrUX?
No. CrUX se construye con usuarios reales de Chrome sobre una ventana móvil de 28 días; tu pipeline usa tus propios navegadores, muestreo y ventanas. Usa tus datos para diagnosticar y CrUX como referencia externa.
¿Qué tasa de muestreo debo usar?
Depende de tu tráfico y de qué tan finos sean tus grupos. Elige una tasa que permita a cada ruta y tipo de dispositivo importante superar tu tamaño mínimo de muestra, y mantenla configurable.
¿Debería enviar los datos RUM a Google Analytics en lugar de a mi propio backend?
Es un atajo válido; la documentación de web-vitals muestra cómo enviar las métricas como eventos de analytics. Cambias control sobre dimensiones, deduplicación y retención por rapidez de implementación.
Comentarios
Todavía no hay comentarios. Sé el primero en compartir lo que piensas.


