Recortamos a la mitad una imagen de cabecera y la primera pantalla quedó más rápida que después de un mes limpiando JavaScript. No tocamos una línea de código. Lo que hacía esperar a la gente no era nuestra lógica: era un PNG exportado al triple del tamaño que cualquier móvil llegaría a mostrar.

Tardamos en verlo: en casi todas las pantallas de un miniprograma, las imágenes son lo más pesado de la página, y son lo último que alguien perfila. Pasamos semanas ajustando el render y casi nada de tiempo preguntando si un recurso a 2x se estaba decodificando en una pantalla de 1x. Cuando lo preguntamos, las mejoras salieron ridículamente baratas.

Dónde se van realmente los bytes

El primer corte es el formato. Para una misma foto, WebP suele pesar bastante menos que PNG o JPEG, y AVIF baja algo más; pero no todos los runtimes de los anfitriones lo decodifican, así que hace falta una alternativa. Nuestra regla ahora es simple: formato moderno primero y, al lado, un formato antiguo que cualquiera sepa abrir. No des por hecho que un solo formato sirve para todos los anfitriones; suena elegante hasta que lo publicas.

El segundo corte es sacar la imagen al tamaño correcto. Decodificar en una pantalla pequeña un recurso preparado para 3x es el despilfarro más común y más innecesario. Con algo tipo srcset generas varios tamaños en el build y el dispositivo se lleva solo la que necesita. El tercero es la carga diferida: las imágenes bajo el pliegue se piden cuando se acercan, de modo que el primer pintado decodifica menos, pero el placeholder tiene que reservar el sitio o el salto de layout molesta más que la espera.

Para redes flojas hay que pensar aparte. Mientras la imagen llega, un placeholder borroso o un bloque de color hace que la pantalla parezca viva en vez de un vacío; y si no llega, no te quedes esperando, sirve algo usable. El CDN se encarga de redimensionar y negociar formato en el borde: ahorra origen y transferencia, a cambio de meter esa lógica en tu ruta crítica.

TécnicaQué ahorraQué añadeCuándo no merece la pena
WebP en vez de PNG/JPEGUna parte grande de los bytes en fotosUn runtime antiguo puede no decodificarlo; hace falta alternativaUn icono diminuto o una forma de un solo color
AVIF en la imagen principalArchivos aún más pequeños a igual calidadCodificación más lenta, soporte irregular, otra variante de buildCuando tu pipeline no puede permitirse un segundo formato
Variantes por tamañoDejar de decodificar un 3x en pantalla pequeñaVarios archivos por imagen y un paso de build que los produzcaUn recurso estático que siempre se renderiza a un tamaño
Carga diferida bajo el pliegueMenos bytes y menos decodificaciones en el primer pintadoLógica de placeholder y riesgo de salto de layoutContenido sobre el pliegue: solo retrasa lo evidente
CDN con transformaciones por dispositivoRedimensionado y negociación de formato en el bordeFactura, reglas de caché y un proveedor en la ruta críticaPantallas internas de poco tráfico, donde un archivo local basta
Placeholder borroso en redes flojasUna pantalla con vida antes de que llegue la imagen realMarcado extra y un recurso de baja calidad que mantenerCuando la imagen es diminuta y llega igualmente al instante

La parte que muerde

Empecemos por la compatibilidad, que es la más pesada. AVIF es precioso sobre el papel, pero en cuanto el runtime viejo de un anfitrión no lo abre, necesitas una variante aparte y una forma de decidir cuál sirves. Cada formato extra es una rama de build más, otra clave de caché y otra forma de que aparezca en producción un «a este usuario le sale en blanco». Al final dejamos AVIF solo para la imagen principal y WebP con alternativa para todo lo demás; no porque AVIF sea malo, sino porque la ganancia no paga esa complejidad.

La complejidad de build es el segundo coste. Sacar varios tamaños parece añadir cuatro líneas de configuración, pero en serio hay que gestionar nombres de recursos derivados, limpieza y el tamaño de los artefactos en CI. La fidelidad al diseño también empuja: sube la compresión y los degradados y las letras finas se emborronan primero, y quien frunce el ceño en la revisión es diseño. Lo discutimos, y el acuerdo fue calidad alta para la imagen principal y compresión fuerte para las miniaturas, en vez de medirlo todo con la misma regla.

El coste del CDN tampoco se puede disimular. Las transformaciones en el borde se cobran por petición, y si el acierto de caché se desordena, la factura y la primera pantalla se estropean a la vez; además es un tercero en tu ruta crítica, y si tose, te quedas en blanco. Por eso en pantallas internas de poco tráfico usamos archivo local sin más. Y va una que no gusta: dar por terminada la optimización porque «ya tenemos CDN» es un error, solo mueve los bytes de sitio; la imagen tiene que seguir siendo pequeña.

Empieza por la única imagen que importa

Así que ahora, en cada pantalla, abrimos con una pregunta: ¿qué imagen concreta está esperando la persona? Esa la exportamos al tamaño real en que se va a mostrar, le damos formato moderno con alternativa y un placeholder que reserve el sitio. Todo lo que queda bajo el pliegue puede esperar.

Lo demás es opcional. Esa imagen no. Si solo tienes una tarde, gástala en el recurso principal y en la petición que lo trae en frío: ahí está el peso, y por mucho que dividas el código no lo vas a mover.

Fuentes