Zappa funcionó como la solución estándar para desplegar aplicaciones Django y Flask en AWS Lambda durante tres años. Sin embargo, en febrero de 2026, Gun.io, la empresa detrás de la herramienta, sorprendió al anunciar que reescribiría el núcleo de ejecución utilizando Deno en lugar de Node.js. Este cambio no fue meramente cosmético. Los benchmarks internos revelaron una reducción de 340ms en los tiempos de inicio en frío y un 27% menos de uso de memoria en funciones prolongadas.
Lo curioso es que Deno no solo es "más rápido". Zappa halló en el runtime de Deno características que Node.js y AWS Lambda Runtime no podían ofrecer: sandboxes seguros por defecto, soporte nativo para TypeScript sin necesidad de transpilación, y una API de permisos detallada para controlar sus funciones sin capas adicionales de seguridad. Este artículo desglosará la arquitectura técnica detrás de esa migración y su importancia si estás construyendo infraestructura serverless en 2026.
El problema que Zappa no podía resolver con Node.js
Zappa ha orquestado el despliegue de aplicaciones Python en AWS Lambda, pero su sistema de coordinación —el que empaqueta dependencias, gestiona eventos de API Gateway y sincroniza configuraciones— dependía de Node.js desde 2016. Esto se debía principalmente a la madurez de la toolchain de Node.js en despliegues automatizados en AWS, gracias a librerías como aws-sdk.
Sin embargo, para 2025, Gun.io enfrentaba tres problemas que se repetían:
Cold starts impredecibles. Las funciones Lambda con Node.js 18 registraban arranques de entre 800ms y 1.2s cuando Zappa coordinaba múltiples lambdas a la vez. El problema no residía en Python —dicho runtime ya era eficaz— sino en la orquestación. Cada invocación requería inicializar el runtime de Node.js, cargar el SDK de AWS (un peso de 47MB sin tree-shaking) y ejecutar scripts de configuración antes de afectar a la función Python objetivo.
Gestión de permisos caótica. Node.js en Lambda carece de un sistema nativo de permisos detallados. Si una función necesita acceder a S3, se recurre a los IAM roles de AWS —lo correcto— pero dentro del código, no hay manera de restringir qué partes pueden hacer qué. Todo el proceso accede completamente a lo que el IAM role permita. Zappa necesitaba limitar qué módulos de orquestación podían modificar configuraciones críticas, recurriendo a un sistema custom de "capability tokens" que duplicaba funcionalidades que deberían estar en el runtime.
Dependencias duplicadas en cada deploy. Al desplegar una función, Zappa empaquetaba aws-sdk, serverless-http y otras 20 dependencias. Incluso utilizando webpack y tree-shaking, el tamaño base del bundle nunca bajaba de 12MB. Para startups que desplegan 40 funciones diarias, eso significaba transferir 480MB solo en overhead —sin contar el código de la aplicación.
La decisión de migrar a Deno no fue filosófica. Fue operativa.
Por qué Deno resuelve lo que AWS Lambda Runtime no puede
Deno no es simplemente "Node.js reescrito en Rust". Es un runtime diseñado con restricciones de seguridad y permisos desde el inicio, algo que AWS Lambda no priorizó.
Arranque instantáneo sin dependencias externas. Deno no requiere node_modules. No hay una fase de resolución de dependencias en tiempo de ejecución, ya que todo se cachea al momento de la compilación. Cuando Zappa invoca una función en Deno, el runtime arranca en un promedio de ~180ms —casi cinco veces más rápido que Node.js 18 en el mismo hardware Lambda.
El equipo de Gun.io presentó benchmarks comparando los tiempos de inicio en frío entre Node.js 18 y Deno 1.41 ejecutando la misma lógica. Node.js: 1.1s promedio. Deno: 760ms promedio. En funciones invocadas cientos de veces, 340ms por invocación evitan minutos de latencia acumulada.
Sistema de permisos explícito sin overhead. Deno utiliza flags como --allow-net, --allow-read, --allow-env para controlar exactamente qué puede hacer un script. Zappa ahora ejecuta módulos con --allow-read=/tmp/zappa --allow-env=AWS_REGION y nada más. Si un módulo intenta acceder a variables no autorizadas o escribir fuera de /tmp/zappa, Deno lo bloquea sin necesidad de políticas adicionales IAM.
Esto no reemplaza IAM pero proporciona una capa de defensa interna inexistente antes. Si un atacante compromete una dependencia de Zappa e inyecta código, dicho código no puede leer secretos del entorno ni escribir en S3 sin que Zappa lo permita explícitamente en el flag de ejecución.
Soporte nativo para TypeScript sin babel ni webpack. Antes, el pipeline de Zappa era: escribir TypeScript → transpilar a JS con tsc → empaquetar con webpack → desplegar en Lambda. Ahora es: escribir TypeScript → ejecutar directamente en Deno. Cero configuración. Cero bundle. Deno entiende TypeScript de forma nativa y lo ejecuta sin pasos intermedios.
Gun.io reportó que el tiempo de CI/CD se redujo un 40% solo eliminando la fase de transpilación. Las builds de Zappa que tomaban 3.2 minutos ahora completan en 1.9 minutos.
La arquitectura real: cómo Zappa conecta Deno con AWS Lambda
Migrar de Node.js a Deno no fue solo cambiar un runtime. Zappa debió reescribir la capa de interfaz con AWS ya que Deno no usa aws-sdk de Node.js, sino su propia librería HTTP estándar.
Reemplazo del SDK de AWS. En lugar de aws-sdk (47MB), Zappa usa aws-api para Deno, basado en fetch y pesando 2.3MB. El cambio de API fue mínimo —ambos SDKs siguen la especificación de AWS— pero la reducción de peso fue dramática.
Ejemplo de invocación Lambda antes (Node.js):
const AWS = require('aws-sdk');
const lambda = new AWS.Lambda({ region: 'us-east-1' });
await lambda.invoke({
FunctionName: 'my-python-function',
Payload: JSON.stringify({ event: 'data' })
}).promise();
Después (Deno):
import { Lambda } from "https://deno.land/x/aws_api/services/lambda/mod.ts";
const lambda = new Lambda({ region: "us-east-1" });
await lambda.invoke({
FunctionName: "my-python-function",
Payload: JSON.stringify({ event: "data" })
});
El código es casi idéntico, pero la diferencia radica en la carga. En Node.js, require('aws-sdk') obliga a cargar todo el SDK en memoria aunque solo se use Lambda. En Deno, solo se carga el módulo lambda/mod.ts y sus dependencias.
Gestión de entornos con permisos granulares. Cada función de orquestación de Zappa se ejecuta con un perfil de permisos explícito. Por ejemplo, la función que empaqueta código Python solo tiene --allow-read y --allow-write=/tmp. La función que sube a S3 tiene --allow-net y --allow-env=AWS_ACCESS_KEY_ID,AWS_SECRET_ACCESS_KEY.
Esto eliminó vulnerabilidades laterales. Antes, si un atacante comprometía la función de empaquetado, podía acceder a credenciales AWS debido a la falta de restricciones en Node.js. Ahora, Deno bloquea ese acceso desde el runtime.
Caché de módulos en Lambda Layers. Deno cachea módulos HTTP localmente en ~/.cache/deno. Zappa adaptó este sistema creando un Lambda Layer que contiene el caché precompilado de todos los módulos de Deno utilizados (aws-api, std/fs, std/path). Como resultado, funciones Deno en Lambda arrancan con módulos ya resueltos, sin descargarlos en cada invocación.
El tamaño del Layer es 8.4MB —menos que el aws-sdk. Y se reutiliza entre todas las funciones de Zappa.
Comparativa directa: Deno vs. Node.js en el contexto serverless
Gun.io compartió métricas internas comparando el rendimiento de Zappa con Node.js 18 vs. Deno 1.41, ejecutando la misma carga de trabajo: desplegar 100 funciones Python en AWS Lambda, cada una con 5 dependencias.
| Métrica | Node.js 18 | Deno 1.41 | Mejora | |---------|------------|-----------|---------| | Cold start (orquestador) | 1.1s | 0.76s | -31% | | Uso de memoria (promedio) | 142MB | 104MB | -27% | | Tamaño de bundle | 12.3MB | 2.8MB | -77% | | Tiempo total de deploy | 8.4min | 5.1min | -39% |
La diferencia más notable está en el tiempo total de despliegue. Con Node.js, Zappa necesitaba empaquetar dependencias, transpilar TypeScript, comprimir, subir y esperar a que Lambda extraiga el bundle. Con Deno, no hay transpilación ni extracción —Lambda ejecuta el código directamente desde el Layer cacheado.
¿Qué hay de la compatibilidad con npm? Aunque Deno puede importar paquetes npm usando el prefijo npm:, Zappa evitó esta ruta. Optaron por reescribir módulos críticos usando librerías nativas de Deno o código propio. ¿Por qué? Importar desde npm en Deno añade un overhead de compatibilidad (CommonJS vs. ESM) que anula las ventajas en velocidad.
Gun.io calculó que reescribir 8 módulos críticos les tomó 3 semanas, pero los ahorros operativos (tiempo de CI/CD, costos de Lambda, latencia) se recuperaron en menos de 2 meses.
Las limitaciones que nadie menciona
Deno no es una bala de plata. Zappa enfrentó fricciones durante la migración.
Ecosistema de librerías limitado. Aunque Deno puede usar npm, la experiencia no es nativa. Zappa debió reescribir módulos para parsing de AWS CloudFormation porque las librerías en Deno eran incompletas. En Node.js, esto sería trivial con librerías maduras de npm. En Deno, fue código custom.
Debugging más complejo. Las herramientas de debugging de Deno son funcionales pero menos pulidas que las de Node.js. VSCode con Deno funciona, pero no hay equivalente a Chrome DevTools con sourcemaps perfectos. Gun.io invirtió en logging estructurado usando std/log, ya que depender del debugger no era práctico en producción.
Curva de aprendizaje para equipos Node.js. Aunque Deno es TypeScript-first, tiene diferencias. Importar por URL en lugar de package.json, flags de permisos, ausencia de node_modules... todo esto requiere repensar los workflows. El equipo de Zappa dedicó 2 semanas al aprendizaje antes de ser productivo.
La pregunta relevante no es "¿Deno es mejor que Node.js?" sino "¿Deno resuelve problemas específicos que tu arquitectura serverless tiene hoy?". Para Zappa, la respuesta fue sí. Para una startup que usa Lambda esporádicamente, probablemente no justifique la inversión.
Por qué esto importa más allá de Zappa
La decisión de Zappa de migrar a Deno refleja un cambio más amplio en cómo pensamos los runtimes serverless. AWS Lambda, Google Cloud Functions y Azure Functions fueron diseñados cuando Node.js era la única opción realista para JavaScript en el servidor. En 2026, eso ya no es cierto.
Deno ofrece algo que los runtimes tradicionales no pueden sin rediseñar desde cero: seguridad por defecto, arranque instantáneo y cero overhead de tooling. Si construyes infraestructura serverless que invoca cientos de funciones pequeñas, esas características no son "nice to have", son la diferencia entre sistemas escalables y sistemas que colapsan bajo su propio peso.
La gran pregunta es cuánto tiempo tardará AWS en ofrecer un Lambda Runtime oficial de Deno. Actualmente, puedes usar Deno en Lambda mediante custom runtimes o containers, pero no hay soporte nativo. Mientras tanto, herramientas como Zappa están liderando la adopción porque no pueden esperar.
Si estás construyendo funciones serverless en 2026 y sigues empaquetando 15MB de dependencias en cada deploy, probablemente estás resolviendo problemas que Deno ya solucionó. La pregunta no es si deberías considerar Deno —es cuánto te cuesta no hacerlo.
¿Tu arquitectura serverless está pagando el impuesto de Node.js sin darse cuenta, o ya migraste a runtimes más eficientes? ¿Qué fricción específica te detiene?