El bug no se reproducía en ningún portátil. Tres personas abrimos el simulador del IDE, recorrimos el flujo completo dos veces y todo salió limpio. En un Android de dos años, el mismo build se quedó colgado un instante en la primera pantalla y después pidió un permiso que el simulador había concedido en silencio semanas antes. Mismo commit, mismo paquete. Lo único que cambiaba era dónde corría.

La cosa es esta: el emulador no miente a propósito. Es un proceso de escritorio, con CPU de escritorio, permisos que ya aprobaste y una única versión del anfitrión, siempre al día. Un miniprograma real vive dentro de la app de otro, en un teléfono que nunca has tenido en la mano, con una versión del anfitrión que no controlas. Rendimiento, diálogos de permisos y versión del anfitrión son los tres agujeros en los que tropezamos una y otra vez, y son sistemáticos, no accidentes.

Dónde se nota de verdad la diferencia

Empieza por el rendimiento. Tu portátil tiene ventilador, está enchufado y su CPU no baja de rendimiento en una demo de dos minutos. Un gama media con tres años sí lo hace, y justo cuando el minijuego lleva un rato corriendo y el cuerpo ya está templado. Hemos visto una pantalla mantener los fotogramas estables en el simulador y empezar a perderlos en cuanto el dispositivo se calentaba. El código no cambió; cambió el silicio.

Los permisos son más traicioneros. En el simulador concedes cámara o ubicación el primer día y te olvidas de que eso existe. Los usuarios reales deniegan, bloquean el aviso para siempre, revocan cosas desde el sistema y te devuelven un estado que tu código nunca ha visto. El fallo casi nunca es un cuelgue: es un mapa en blanco, una subida que no hace nada, un botón muerto porque una rama daba por hecho el consentimiento.

Y está el anfitrión. Cada uno publica su librería base, y la gente no actualiza según tu calendario. Una API que se comporta de una forma en el runtime actual puede comportarse distinto, o no existir, en una versión de hace dos años. Si solo pruebas contra la última, estás probando contra un build que buena parte de tu audiencia jamás instaló.

DiferenciaEn el simuladorEn un dispositivo realCómo detectarlo antes
Presupuesto de fotogramasCPU de escritorio, sin estrangulamientoEl gama media baja al calentarsePerfilar en el móvil más barato que soportes, tras diez minutos de uso
Avisos de permisosConcedidos una vez y olvidadosDenegación, bloqueo permanente, revocación del sistemaInstalación limpia con todos los permisos revocados antes de cada pasada
Librería base del anfitriónSiempre la más recienteUsuarios anclados a versiones de hace añosFijar una versión mínima y dejar un dispositivo en ella
RedWi-Fi de oficina, sin pérdida de paquetesSeñal floja, portales cautivos, cortes a media peticiónLimitar a un perfil lento y cortar la conexión durante la carga
AlmacenamientoSe limpia cuando te apeteceLímites de cuota y borrados que no provocasteLlenar la caché y medir el arranque en frío
EntradaClics de ratón precisosDedos grandes, deslizamientos al borde, muescas de pantallaPasarle el móvil a alguien que no haya visto el diseño

Lo que cuesta una matriz de dispositivos de verdad

No vamos a fingir que la respuesta sea «prueba en dispositivos reales» y ya. Una matriz con cinco anfitriones, tres versiones de sistema y un puñado de móviles baratos es cara de comprar y pesada de mantener: cargados, actualizados y con sesión abierta en cuentas reales. Las granjas de dispositivos en la nube ayudan, pero no son lo mismo que un teléfono con conexión irregular en la mano de alguien, y la factura sube con cada combinación que añades.

La automatización también tiene techo. Puedes guionizar toques y capturas, pero no el interruptor de permisos del sistema, ni una app anfitriona que se actualiza de madrugada, ni una notificación que aterriza a mitad del flujo. Nuestra suite automática cubre bien el camino feliz y mal los estados raros, justo al revés de donde viven los bugs de los miniprogramas. Aprendimos a leer un pipeline en verde como una señal de que lo obvio va bien, no de que esto funciona.

Y hay problemas que no existen hasta que llega tráfico real. Un despliegue gradual del anfitrión, una rareza de red regional, un modelo que no compramos: eso aparece por releases por fases y tickets de soporte, no en un laboratorio. Incomoda, porque significa que no puedes comprar certeza con más hardware. Solo puedes acortar la distancia entre publicar algo y darte cuenta de que se rompió.

Publica poco y luego observa

Así que dejamos de intentar que el simulador fuera honesto y empezamos a tratarlo como lo que es: un sitio rápido para comprobar lógica, no un sitio para firmar el visto bueno. La firma ocurre en una matriz pequeña que de verdad mantenemos: un móvil antiguo por anfitrión, uno clavado a la versión mínima de la librería base y otro que dejamos a propósito caliente y lleno de trastos. Todo lo demás sale como release por fases a un trozo de usuarios reales, con las rutas de permiso denegado y arranque en frío instrumentadas antes de ampliar el despliegue.

Ese orden importa más que las herramientas. Caza los bugs de lógica donde iterar es barato, los de dispositivo en unos pocos móviles reales, y acepta que la última categoría solo se ve en producción. A los equipos que les va mal no son los que tienen un laboratorio modesto, sino los que creyeron que un simulador limpio significaba que ya habían terminado.

Fuentes