Revisamos un catálogo de mini-juegos servidos dentro de super apps del sudeste asiático, y el peor momento no fue un crash ni un bug. Fue la pantalla de carga. Cerca del 40% de quienes tocaron un ícono nunca vieron el primer frame interactivo: se fueron mientras el spinner seguía girando. Nadie presentó una queja. Simplemente se marcharon.
En la web abierta, un sitio lento te cuesta posición y algunos puntos de conversión. Dentro de un super app la apuesta es más aguda. No hay un paso de instalación que genere buena voluntad, y el usuario está a un desliz de una docena de otros mini-programas que hacen más o menos lo mismo. La atención en un super app se presta, no se posee. La primera pantalla es toda la relación.
Las tres palancas que de verdad importan
La mayoría de los equipos persiguen el número equivocado. Optimizan una ruta que ya es rápida e ignoran las tres cosas que deciden la primera pintura.
Tamaño del paquete. Muchos frameworks envían su propio runtime junto con tu código, así que cada mini-programa arrastra 1–2 MB al dispositivo antes de mostrar un solo píxel. Si el runtime del host se comparte entre todos los mini-programas del dispositivo, tu paquete se desploma a unos pocos cientos de KB. Por lo general es la mayor ganancia única, y es gratis si la plataforma lo maneja.
Parseo y ejecución. Código pesado a nivel superior, un bucle síncrono gigante, importar toda la librería de UI cuando solo usas tres componentes — todo eso corre antes de que el usuario vea algo. Divide el código por ruta, carga perezosamente lo que no está en la primera pantalla y deja de hacer en el import trabajo que podría esperar.
El primer viaje de datos. Este es el asesino silencioso. Los mini-programas que bloquean la primera pintura en una llamada a la API — y esa API espera a tres servicios aguas abajo — convierten un render de 400 ms en dos segundos mirando un esqueleto. Renderiza primero una carcasa, luego busca. El ojo acepta un frame vacío mucho más tiempo que uno congelado.
Lo que cambia un runtime
Un runtime propio del host te quita las tres palancas de las manos, pero para bien. Precalienta el motor de JS una vez al abrir la app, así tu mini-programa no paga un impuesto de arranque en frío cada vez que se abre. Comparte un runtime central entre todos los mini-programas del dispositivo, y por eso tu paquete puede ser diminuto. Y en el momento en que el pulgar del usuario se acerca a un ícono — a veces antes de que aterrice — prefetcha la primera llamada de datos.
Esa es la diferencia entre un arranque en frío y uno en caliente. Hemos visto primeras pantallas bajar del rango de 2 segundos a menos de 700 ms en un Android de gama media, el tipo que la mayoría de tus usuarios realmente lleva.
| Palanca | Mini-programa ingenuo | Optimizado por runtime |
|---|---|---|
| Paquete a descargar | 1,8 MB (runtime propio) | 220 KB (compartido) |
| Motor de JS | Arranque en frío cada apertura | Precalentado una vez |
| Primera pintura | Bloqueada en la primera API | Carcasa primero, datos después |
| Apertura repetida | Re-descarga + re-parseo | Carcasa en caché + prefetch |
| Primera pantalla típica | 2,1–2,8 s | 0,4–0,7 s |
Las concesiones que nadie menciona
Precalentar el motor cuesta un poco de memoria que queda ociosa hasta usarse. El prefetch desperdicia una petición cuando un usuario toca y rebota antes de que los datos importen. Ninguno es gratis, y una plataforma descuidada gastará ese presupuesto en mini-programas que el usuario nunca abre. La solución es prefetchear solo lo que realmente es probable que se toque, y dejar que la caché desaloje con agresividad. Pretender que la optimización no tiene costo es cómo los equipos entregan un runtime que se siente más pesado que el problema.
Mide donde están tus usuarios
Aquí está la cosa: una primera pantalla de 600 ms en un gama alta en un laboratorio son 2 segundos en un Android de 120 € en Yakarta con señal 4G que cae a 3G. Si mides en el lugar equivocado, reportarás éxito mientras tus usuarios reales rebotan. Toma la mediana de primera pantalla de dispositivos reales, no simuladores, y vigila el percentil 75: ese es el número que está matando tu embudo en silencio.
Un mini-programa que abre al instante se siente menos como un sitio web y más como una función nativa. Esa es toda la propuesta. Arregla la pantalla de carga y todo lo demás — retención, conversión, boca a boca — tiene una oportunidad de importar.
Fuentes
- web.dev — First Contentful Paint — la métrica que mejor predice si un usuario espera o se va; la misma curva aplica dentro de un runtime de mini-programa.
- MDN — Rendimiento web — cómo el parseo, la ejecución y el bloqueo de render realmente detienen el primer frame.
- Documentación de WeChat Mini Program — framework — el tope de 2 MB que hace de los runtimes compartidos la única forma de seguir pequeño.
- Think with Google — Velocidad móvil — investigación de latencia que muestra que el retraso se convierte directamente en abandono.
- StatCounter — Cuota móvil — por qué el dispositivo mediano de tu mercado no es el de tu escritorio.