Portabilidad multi-runtime Una de las grandes ventajas de Hono es poder trabajar en diferentes runtimes y plataformas. La formación cubre Node.js, Bun, Deno, Cloudflare Workers, Vercel, AWS Lambda y otros entornos.
1
TypeScript de extremo a extremo El curso trabaja validación, RPC, clientes tipados y contratos de API para reducir errores entre backend y frontend. Esto mejora mantenibilidad y experiencia de desarrollo.
Personaliza el temario al 100% para tu equipo
Diseñamos una formación a medida utilizando los documentos y flujos de trabajo reales de tu empresa.
Nueva Plataforma de E-learningFormación en directo con plataforma de apoyo para reforzar el aprendizaje
Acceso a las grabaciones
Los alumnos podrán revisar las sesiones grabadas para repasar conceptos clave, recuperar explicaciones concretas o reforzar aquellos contenidos que necesiten después de la clase en directo.
Recursos formativos
Materiales, sesiones grabadas y documentación de apoyo quedan centralizados en la plataforma para que el equipo pueda consultarlos durante y después de la formación.
Confirmación de asistencia
La plataforma permite registrar y confirmar la asistencia de los participantes, facilitando el seguimiento de la formación y la gestión documental necesaria para la bonificación FUNDAE.
Programa formativo
Temario del curso
Encuentra todo el temario del curso aquí.
Temario
Situar Hono como framework web moderno para backends TypeScript, APIs, microservicios, edge computing y serverless.
Comprender por qué Hono se apoya en Web Standards como Request, Response, URL, Headers y Fetch API.
Diferenciar Hono de Express, Fastify, NestJS, Elysia, Koa, Oak y frameworks full stack como Next.js o Remix.
Reconocer cuándo no es la opción ideal: aplicaciones monolíticas muy opinionadas, arquitecturas enterprise con DI pesada o proyectos que exigen una estructura rígida.
Entender la filosofía de Hono: API limpia, bajo peso, rendimiento alto, TypeScript first y portabilidad entre runtimes.
Revisar el concepto de multi-runtime y sus implicaciones para arquitectura, despliegue, dependencias y pruebas.
Reconocer cuándo no es la opción ideal: aplicaciones monolíticas muy opinionadas, arquitecturas enterprise con DI pesada o proyectos que exigen una estructura rígida.
Entender la filosofía de Hono: API limpia, bajo peso, rendimiento alto, TypeScript first y portabilidad entre runtimes.
Revisar el concepto de multi-runtime y sus implicaciones para arquitectura, despliegue, dependencias y pruebas.
Reconocer cuándo no es la opción ideal: aplicaciones monolíticas muy opinionadas, arquitecturas enterprise con DI pesada o proyectos que exigen una estructura rígida.
Entender la filosofía de Hono: API limpia, bajo peso, rendimiento alto, TypeScript first y portabilidad entre runtimes.
Revisar el concepto de multi-runtime y sus implicaciones para arquitectura, despliegue, dependencias y pruebas.
Crear una primera aplicación Hono con endpoint raíz y respuesta de texto o JSON.
Ejecutar servidor local según runtime: Node.js, Bun, Deno o emulador de plataforma.
Resolver problemas frecuentes de versión de Node.js, módulos ESM, imports, templates y dependencias.
Preparar un repositorio Git base con README, `.gitignore`, estructura inicial y convenciones de proyecto.
Tema 3: Routing esencial y diseño de endpoints
Crear rutas GET, POST, PUT, PATCH, DELETE y OPTIONS con handlers claros y separados.
Trabajar rutas estáticas, rutas dinámicas, parámetros de path, query params y wildcard routes.
Organizar endpoints por recursos: usuarios, productos, pedidos, sesiones, incidencias o entidades de negocio.
Diseñar rutas REST con nombres coherentes, pluralización, jerarquías, status codes y payloads consistentes.
Usar route grouping y composición de subaplicaciones para dividir módulos funcionales.
Montar routers por dominio sin crear un único archivo gigante de rutas.
Gestionar rutas no encontradas con `notFound` y respuestas uniformes.
Crear convenciones para versionado de API: `/api/v1`, `/api/v2` o versionado por headers cuando procede.
Evitar rutas ambiguas, endpoints con demasiadas responsabilidades y handlers mezclados con lógica de negocio.
Realizar ejercicio de diseño de API REST modular para una aplicación empresarial.
Tema 4: Context, Request, Response y Web Standards
Comprender el objeto `Context` como punto central para acceder a request, response, variables, bindings y helpers.
Leer parámetros de ruta, query params, headers, body, form data, JSON y cookies.
Crear respuestas con `c.text`, `c.json`, `c.html`, `c.redirect`, status codes y headers personalizados.
Diferenciar Request estándar, HonoRequest, Context y Response para evitar confusiones al diseñar servicios.
Manipular headers de respuesta para caché, seguridad, contenido, CORS y trazabilidad.
Trabajar con `c.req.valid` cuando existe validación previa.
Utilizar variables de contexto para pasar datos entre middleware y handlers.
Crear respuestas de error uniformes con estructura, código, mensaje, detalles y request ID.
Entender cómo Web Standards facilitan portabilidad entre Cloudflare Workers, Node.js, Bun y Deno.
Realizar ejercicio de endpoints que procesan JSON, parámetros, headers y respuestas tipadas.
Tema 5: Arquitectura modular de aplicaciones Hono
Dividir la aplicación en módulos por dominio, feature, capa o recurso.
Separar rutas, handlers, servicios, repositorios, esquemas, middlewares, tipos y utilidades.
Crear subaplicaciones Hono montadas bajo prefijos como `/api/users`, `/api/auth` o `/api/admin`.
Diseñar composición de rutas manteniendo inferencia de tipos para RPC y clientes tipados.
Evitar acoplar handlers HTTP directamente a lógica de base de datos compleja.
Crear servicios reutilizables que puedan probarse sin levantar el servidor.
Gestionar dependencias mediante factories, context variables o patrones simples sin sobreingeniería.
Definir estructura escalable para equipos: `routes`, `modules`, `middlewares`, `lib`, `schemas`, `tests` y `infra`.
Documentar convenciones de proyecto para que nuevos desarrolladores entiendan dónde añadir código.
Refactorizar una app monolítica Hono hacia arquitectura modular.
Tema 6: Middleware en Hono: conceptos, orden y composición
Comprender el ciclo middleware-handler y el uso de `next()` para continuar procesamiento.
Aplicar middlewares globales, por path, por método o por grupo de rutas.
Entender el orden de ejecución y cómo afecta a logging, CORS, auth, validación y errores.
Crear middlewares propios para request ID, métricas, auditoría, inyección de dependencias o validación de permisos.
Pasar datos desde middleware a handlers mediante variables de contexto tipadas.
Cortar la ejecución devolviendo una respuesta desde middleware cuando procede.
Evitar middlewares demasiado grandes que mezclan seguridad, logging, lógica de negocio y validación.
Combinar middlewares integrados y personalizados de forma explícita y mantenible.
Documentar qué middleware aplica a cada zona de la API.
Realizar ejercicio de pipeline con logger, request ID, CORS, auth, validación y handler final.
Tema 7: Middleware integrado: CORS, logger, secure headers, compress y timing
Configurar CORS para frontends concretos, entornos de desarrollo, dominios corporativos y APIs públicas.
Evitar configuraciones CORS demasiado abiertas en endpoints privados o administrativos.
Usar logger para desarrollo y adaptar estrategia de logging en producción.
Aplicar secure headers para reforzar seguridad HTTP en endpoints y respuestas HTML.
Usar compression solo donde el runtime no comprime automáticamente o donde aporte valor real.
Medir tiempos con timing middleware y detectar endpoints lentos.
Configurar pretty JSON para desarrollo sin afectar producción.
Aplicar trailing slash y method override cuando el proyecto lo requiere.
Crear políticas por entorno: desarrollo, staging, producción, edge y serverless.
Realizar laboratorio de hardening básico de una API Hono con middlewares integrados.
Tema 8: Autenticación y autorización
Implementar Basic Auth para endpoints internos, demos, healthchecks protegidos o zonas administrativas simples.
Implementar Bearer Auth para APIs internas, webhooks o servicios con token compartido.
Implementar JWT Auth con cabecera Authorization o cookie según arquitectura.
Firmar, verificar y renovar tokens JWT con criterios de expiración, issuer, audience y secret management.
Integrar proveedores externos mediante middleware de terceros: OAuth, OIDC, Auth.js, Clerk, Firebase, Cloudflare Access o JWKS.
Separar autenticación, autorización, roles, permisos y ownership de recursos.
Crear middleware de autorización para roles como admin, user, support, service o internal.
Proteger rutas sensibles y evitar confiar solo en validación frontend.
Gestionar errores 401 y 403 de forma clara y auditable.
Realizar ejercicio de API con login, JWT, rutas protegidas, roles y pruebas de permisos.
Tema 9: Validación de datos con Validator, Zod, Valibot y Standard Schema
Validar body JSON, query params, path params, headers y form data antes de ejecutar lógica de negocio.
Usar validator integrado de Hono para casos simples y control directo.
Integrar Zod, Valibot, ArkType, TypeBox u otras librerías compatibles según estándar del proyecto.
Crear esquemas reutilizables para DTOs, filtros, paginación, creación, actualización y respuestas.
Devolver errores de validación consistentes con código, campo, mensaje y detalle.
Diferenciar validación de entrada, validación de negocio y validación de persistencia.
Evitar esquemas duplicados entre backend, frontend, tests y documentación.
Tipar `c.req.valid` para que handlers reciban datos ya validados.
Crear validaciones para fechas, UUIDs, emails, enums, arrays, objetos anidados y paginación.
Realizar ejercicio de API validada con errores claros y contratos reutilizables.
Tema 10: Errores, excepciones y respuestas consistentes
Crear una estrategia centralizada de manejo de errores con `onError`.
Diferenciar errores de validación, autenticación, autorización, negocio, infraestructura y errores inesperados.
Usar HTTPException cuando conviene devolver errores HTTP controlados.
Crear formato estándar de error con `code`, `message`, `details`, `requestId` y `timestamp`.
Evitar exponer stack traces, secrets, SQL, tokens o información interna en producción.
Registrar errores con contexto suficiente para debugging y observabilidad.
Mapear errores de base de datos, servicios externos y validadores a respuestas HTTP.
Crear errores de dominio independientes del framework para mejorar testabilidad.
Diseñar páginas o respuestas not found, forbidden, bad request e internal error.
Realizar ejercicio de API con error handler global y catálogo de errores uniforme.
Tema 11: RPC tipado y clientes TypeScript
Comprender Hono RPC como mecanismo para compartir especificación de API entre servidor y cliente.
Exportar `AppType` o tipos de rutas para que el cliente infiera inputs y outputs.
Crear cliente tipado con `hc` y consumir endpoints desde frontend, Node.js u otro cliente TypeScript.
Aprovechar inferencia de tipos desde validadores y respuestas `c.json`.
Diseñar rutas para que la inferencia RPC sea útil, estable y fácil de mantener.
Evitar patrones que rompen inferencia por handlers demasiado dinámicos o respuestas inconsistentes.
Separar API pública documentada con OpenAPI de APIs internas con RPC tipado cuando procede.
Gestionar errores, status codes y tipos de respuesta en clientes RPC.
Crear monorepo o workspace compartido para backend y frontend con tipos consistentes.
Realizar ejercicio de frontend TypeScript consumiendo API Hono con RPC end-to-end type-safe.
Tema 12: OpenAPI, documentación y contratos de API
Generar documentación OpenAPI usando middleware y librerías compatibles con validadores como Zod o Valibot.
Diseñar rutas con descripción, tags, parámetros, request body, responses y ejemplos.
Publicar documentación interactiva con Swagger UI, Scalar u otra herramienta compatible.
Mantener OpenAPI como contrato vivo y no como documentación escrita a mano sin sincronización.
Diferenciar RPC interno de documentación OpenAPI para terceros, partners o equipos no TypeScript.
Versionar especificaciones y documentar cambios breaking.
Crear ejemplos de payload correctos, errores, paginación, filtros y autenticación.
Integrar generación de OpenAPI en CI para detectar roturas de contrato.
Evitar documentar endpoints incompletos, inseguros o experimentales como API estable.
Realizar ejercicio de API documentada con OpenAPI, validación y cliente externo.
Tema 13: Bases de datos, ORMs y persistencia
Integrar Hono con bases de datos SQL como PostgreSQL, MySQL, SQLite o servicios serverless.
Usar ORMs o query builders como Drizzle, Prisma, Kysely o acceso SQL directo según el runtime y la necesidad.
Diseñar capa de repositorio o data access separada de handlers HTTP.
Gestionar conexiones en Node.js, serverless y edge evitando patrones que agotan conexiones.
Trabajar con migraciones, seeds, transacciones y consistencia de datos.
Validar entrada antes de persistir y validar salida antes de responder.
Gestionar errores de constraints, claves únicas, registros no encontrados y conflictos.
Diseñar paginación, filtros, ordenación, búsqueda y respuestas parciales.
Usar servicios edge-friendly como Cloudflare D1, KV, Durable Objects, R2, Neon, Turso, Supabase o PlanetScale cuando encaja.
Realizar ejercicio de API CRUD conectada a base de datos con validación, errores y tests.
Tema 14: Integraciones externas, webhooks y servicios HTTP
Consumir APIs externas con fetch estándar desde handlers o servicios.
Diseñar clientes HTTP internos para servicios externos con timeout, retries, errores y logging.
Validar webhooks entrantes con firma, secret, timestamp y replay protection.
Crear endpoints de webhook idempotentes para evitar duplicados por reintentos.
Gestionar respuestas lentas, servicios caídos, rate limits y errores 5xx.
Separar integración externa de lógica HTTP de Hono para facilitar tests.
Usar variables de entorno para URLs, tokens, claves y configuración por entorno.
Registrar llamadas externas sin exponer datos sensibles.
Crear jobs o procesos diferidos cuando un webhook no debe bloquearse.
Realizar ejercicio de integración con API externa y recepción segura de webhooks.
Tema 15: Cookies, sesiones, CSRF y formularios
Leer y escribir cookies con helpers de Hono de forma segura.
Configurar atributos `HttpOnly`, `Secure`, `SameSite`, path, domain y expiración.
Diseñar sesiones stateless con JWT o sesiones stateful con almacenamiento externo según arquitectura.
Proteger formularios y endpoints sensibles frente a CSRF cuando se usan cookies.
Procesar `form-data`, `multipart/form-data` y formularios HTML.
Validar uploads y controlar tamaño de body con middleware adecuado.
Gestionar login, logout, expiración y rotación de sesión.
Diferenciar autenticación para SPA, SSR, API interna, mobile y server-to-server.
Evitar almacenar información sensible directamente en cookies sin cifrado o firma adecuada.
Realizar ejercicio de flujo de sesión con cookies seguras, CSRF y endpoint protegido.
Tema 16: Streaming, SSE, WebSockets y respuestas progresivas
Comprender cuándo usar streaming HTTP para respuestas largas, generación progresiva o procesamiento incremental.
Crear respuestas stream con Web Streams API y helpers de Hono.
Implementar Server-Sent Events para notificaciones, progreso de tareas o actualizaciones en tiempo real simples.
Evaluar WebSockets cuando se necesita comunicación bidireccional sostenida.
Controlar timeouts, cancelación, cierres de conexión y errores durante streaming.
Diseñar APIs que no bloqueen el runtime con tareas largas innecesarias.
Integrar streaming con servicios de IA, logs, progreso de importación o reporting.
Evitar streaming si el cliente, proxy o runtime no lo soporta de forma fiable.
Probar streaming en local y en plataforma de despliegue real.
Realizar ejercicio de endpoint SSE o streaming con progreso de proceso.
Tema 17: JSX, HTML, SSR ligero y respuestas web
Usar Hono para devolver HTML y construir respuestas server-rendered ligeras.
Configurar JSX en proyectos Hono cuando se necesita renderizado de vistas simples.
Crear layouts, componentes, páginas y fragmentos reutilizables.
Combinar APIs JSON y páginas HTML en una misma app cuando el caso lo justifica.
Integrar JSX Renderer, html helper y middleware relacionado.
Servir formularios, paneles internos, landing pages o dashboards simples sin framework pesado.
Gestionar assets estáticos según runtime y plataforma.
Evitar convertir Hono en un framework full stack complejo si el proyecto requiere otra herramienta.
Comparar SSR ligero con SPA, Next.js, Astro o Remix según necesidades.
Realizar ejercicio de panel administrativo básico con HTML/JSX y endpoints JSON.
Tema 18: Seguridad web y hardening de APIs Hono
Aplicar secure headers, CORS restrictivo, CSRF, body limit, rate limiting externo y validación estricta.
Gestionar secrets con variables de entorno, plataformas cloud y gestores seguros.
Evitar logging de tokens, cookies, contraseñas, datos personales y payloads sensibles.
Diseñar respuestas de error que no filtren detalles internos.
Proteger endpoints administrativos, webhooks, jobs internos y healthchecks sensibles.
Revisar dependencias, middleware de terceros y librerías de autenticación.
Implementar controles de autorización por recurso, tenant, organización o usuario.
Diseñar auditoría de acciones críticas con request ID, usuario, IP, recurso y resultado.
Preparar checklist OWASP adaptado a APIs ligeras Hono.
Realizar ejercicio de hardening de una API vulnerable.
Tema 19: Testing con Vitest, testClient y pruebas de contrato
Crear tests unitarios para servicios, funciones, validadores y lógica de negocio.
Probar endpoints Hono sin levantar servidor real cuando el framework lo permite.
Usar `app.request` o clientes de test para validar status, JSON, headers y errores.
Crear tests de integración con base de datos de prueba, mocks o contenedores.
Probar middlewares de auth, CORS, errores, request ID y validación.
Generar fixtures, factories y datos de prueba reutilizables.
Validar OpenAPI o contratos para evitar cambios breaking.
Integrar tests en CI con lint, typecheck y build.
Medir cobertura con criterio sin perseguir porcentajes vacíos.
Realizar ejercicio de suite de tests para API REST modular.
Tema 20: Logging, observabilidad y diagnóstico en producción
Diseñar logging estructurado con request ID, método, path, status, duración y usuario cuando procede.
Diferenciar logs de desarrollo, logs de producción, auditoría, métricas y trazas.
Integrar Hono con Sentry, OpenTelemetry, plataformas cloud o sistemas de observabilidad.
Registrar errores externos, timeouts, validaciones fallidas y latencias anómalas.
Crear healthchecks, readiness checks y endpoints internos de diagnóstico.
Medir métricas clave: tasa de error, latencia p95/p99, throughput, cold starts y consumo de recursos.
Evitar logs ruidosos que no ayudan a resolver incidencias.
Diseñar troubleshooting por runtime: Node.js, Workers, Lambda, Vercel, Bun o Deno.
Crear runbooks para errores de despliegue, auth, base de datos, CORS y timeouts.
Realizar ejercicio de diagnóstico de una API con errores intermitentes.
Tema 21: Rendimiento, edge computing y optimización
Entender el router de Hono, coste de middleware, tamaño de bundle y latencia de respuesta.
Medir rendimiento antes de optimizar, usando herramientas de benchmark y métricas reales.
Reducir middlewares innecesarios en rutas críticas.
Optimizar validaciones, serialización JSON, consultas externas y acceso a base de datos.
Usar cache, ETag, headers de control y estrategias edge cuando el caso lo permite.
Diseñar endpoints idempotentes y cacheables donde sea posible.
Entender cold starts, warm starts, límites de CPU, memoria y duración en serverless.
Elegir runtime según patrón: edge global, Node.js tradicional, Bun, Deno, Lambda o Cloud Run.
Evitar optimizaciones micro que complican el código sin impacto medible.
Realizar ejercicio de profiling y optimización de endpoint lento.
Tema 22: Despliegue en Node.js, Bun y Deno
Desplegar Hono en Node.js usando el adapter correspondiente y servidor HTTP.
Configurar Dockerfile para producción con build, dependencias, usuario no root y variables.
Ejecutar Hono con Bun cuando se busca rapidez de desarrollo o runtime alternativo.
Ejecutar Hono con Deno respetando permisos, imports y configuración del runtime.
Gestionar archivos estáticos, rutas, entorno y procesos de arranque.
Configurar graceful shutdown, healthchecks y logs en Node.js.
Preparar pipelines CI/CD para build, tests, typecheck y despliegue.
Comparar diferencias de runtime, dependencias, APIs disponibles y soporte operativo.
Resolver problemas de ESM, imports, adapters y compatibilidad de paquetes.
Realizar ejercicio de despliegue local y contenedorizado de una API Hono.
Tema 23: Despliegue en Cloudflare Workers, Vercel, AWS Lambda y Fastly
Crear proyecto Hono para Cloudflare Workers con Wrangler y bindings de entorno.
Usar Cloudflare KV, D1, R2 o Durable Objects cuando el diseño lo requiere.
Desplegar Hono en Vercel Functions o Edge según plantilla y limitaciones del proyecto.
Desplegar Hono en AWS Lambda con API Gateway, CDK o infraestructura equivalente.
Evaluar Lambda@Edge, Fastly Compute, Netlify, Azure Functions y Google Cloud Run según arquitectura.
Gestionar variables de entorno, secrets, dominios, routing y observabilidad en cada plataforma.
Adaptar static assets, streaming, caching y conexiones externas al runtime elegido.
Crear estrategia multi-runtime sin prometer portabilidad total cuando hay dependencias específicas.
Diseñar matriz de decisión de despliegue por coste, latencia, región, operación y compatibilidad.
Realizar laboratorio de despliegue en al menos dos runtimes distintos.
Tema 24: Hono en arquitecturas empresariales
Diseñar Hono como API pública, API interna, BFF, gateway ligero, webhook receiver o microservicio.
Integrar Hono con frontends React, Vue, Svelte, Astro, Next.js o aplicaciones móviles.
Definir contratos de API, versionado, autenticación, rate limits y trazabilidad.
Aplicar patrones de arquitectura hexagonal o clean architecture sin sobrecargar el framework.
Diseñar servicios pequeños con responsabilidad clara y boundary funcional.
Integrar Hono con colas, eventos, cron jobs, workers y tareas diferidas.
Evaluar uso de Hono en monorepos con pnpm workspaces, Turborepo o Nx.
Crear librerías compartidas de tipos, validadores, clientes y utilidades.
Gestionar multi-tenant, organizaciones, permisos y separación de datos.
Diseñar checklist de producción para servicios Hono en empresa.
Tema 25: Comparativa técnica y criterios de elección
Comparar Hono con Express en simplicidad, tipos, Web Standards, middleware y portabilidad.
Comparar Hono con Fastify en rendimiento, plugins, ecosistema y estructura de proyecto.
Comparar Hono con NestJS en arquitectura opinionada, inyección de dependencias, learning curve y tamaño.
Comparar Hono con Elysia en Bun, tipado, rendimiento y ecosistema multi-runtime.
Comparar Hono con frameworks full stack cuando se necesita SSR, routing web, assets y frontend integrado.
Decidir cuándo Hono es ideal para APIs pequeñas, servicios edge, webhooks, BFFs o backends serverless.
Identificar riesgos de adoptar Hono en equipos acostumbrados a frameworks enterprise más estructurados.
Crear criterios de adopción por equipo: experiencia TypeScript, runtime objetivo, seguridad, observabilidad y mantenimiento.
Diseñar estrategia de migración desde Express/Fastify a Hono por módulos.
Preparar recomendación técnica para dirección o comité de arquitectura.
Tema 26: Proyecto Final
Crear una API profesional con Hono, TypeScript, estructura modular, validación, seguridad y despliegue real.
Diseñar dominio funcional con usuarios, autenticación, recursos protegidos, operaciones CRUD y reglas de negocio.
Configurar proyecto con `create-hono`, TypeScript strict, ESLint, Prettier, Vitest y estructura de carpetas profesional.
Implementar rutas REST versionadas con subaplicaciones Hono por módulo.
Crear middlewares de request ID, logging, CORS, secure headers, auth, roles y manejo de errores.
Diseñar esquemas de validación con Zod, Valibot u otra librería compatible.
Crear respuestas de error y éxito uniformes con status codes, mensajes, detalles y trazabilidad.
Integrar base de datos con capa de repositorio, migraciones y datos de prueba.
Implementar autenticación JWT o Bearer Auth con rutas públicas, privadas y administrativas.
Generar documentación OpenAPI con ejemplos, tags, request bodies, responses y errores.
Crear cliente RPC tipado para consumir la API desde un frontend o script TypeScript.
Implementar tests unitarios, tests de integración y pruebas de endpoints.
Añadir observabilidad con logs estructurados, métricas básicas, healthcheck y manejo de errores externos.
Optimizar endpoints críticos con caché, ETag, validación eficiente o consultas mejoradas.
Desplegar el proyecto en Node.js y en una plataforma serverless o edge como Cloudflare Workers, Vercel o AWS Lambda.
Documentar arquitectura, decisiones técnicas, seguridad, variables de entorno, despliegue, testing y mantenimiento.
Presentar la solución final defendiendo elección de runtime, estructura, contratos, seguridad, rendimiento y escalabilidad.
Perfiles profesionales
Pensado para quienes deben dominar Hono Framework en su día a día
Desarrolladores backend TypeScript y Node.js
Este curso encaja con perfiles que ya trabajan con Express, Fastify, NestJS u otros frameworks y quieren dominar una alternativa ligera, rápida y portable. La formación les permite crear APIs limpias, tipadas y preparadas para edge o serverless sin arrastrar complejidad innecesaria.
Desarrolladores full stack y frontend avanzados
Los perfiles que trabajan con React, Vue, Svelte, Next.js, Astro o frontends modernos podrán usar Hono para construir backends, BFFs, APIs internas, endpoints serverless y capas RPC tipadas con una experiencia muy cercana a TypeScript.
Preguntas frecuentes
Resolvemos todas tus dudas sobre nuestra formación en Hono Framework
Explora las respuestas a las preguntas que guian a nuestra comunidad. Aqui encontraras claridad sobre como funciona todo, desde el acceso hasta los detalles de los cursos. Si buscas respuestas, este es el lugar para comenzar.
Hono es un framework web ligero, rápido y basado en Web Standards para crear APIs y aplicaciones backend con TypeScript en múltiples runtimes.
No. Aunque encaja muy bien con Cloudflare Workers, también puede ejecutarse en Node.js, Bun, Deno, Vercel, AWS Lambda, Fastly Compute, Netlify, Google Cloud Run y otros entornos.
Sí, es muy recomendable. Hono puede usarse con JavaScript, pero su mayor valor aparece cuando se trabaja con TypeScript, tipos, validación y RPC.
Sí. El curso compara Hono con Express, Fastify, NestJS, Elysia y frameworks full stack para saber cuándo elegir cada opción.
Sí. Se trabajan Basic Auth, Bearer Auth, JWT, cookies, sesiones, CSRF, roles, autorización y opciones de integración con proveedores externos.
Sí. El curso incluye generación de documentación OpenAPI, validación, contratos, ejemplos, tags, errores y publicación de documentación interactiva.
Hono RPC permite compartir tipos de la API entre servidor y cliente TypeScript, facilitando clientes tipados e inferencia de entradas y salidas.
Sí. Se trabaja integración con SQL, ORMs o query builders como Drizzle, Prisma o Kysely, además de bases serverless y servicios edge-friendly.
Sí. Se trabajan tests unitarios, integración, endpoints, middlewares, validación, errores y pruebas automatizadas con Vitest u otras herramientas compatibles.
Sí. Se trabajan despliegues en Node.js, Bun, Deno, Cloudflare Workers, Vercel, AWS Lambda, Fastly y otras plataformas según el caso.
Sí. Hono es muy adecuado para microservicios, APIs internas, BFFs, webhooks, gateways ligeros y servicios serverless.
Sí. Se abordan router, middlewares, caché, ETag, latencia, cold starts, payloads, consultas externas, logs y optimización real basada en métricas.
El curso se centra en backend y APIs, pero incluye consumo desde frontend TypeScript mediante RPC, además de HTML/JSX y SSR ligero cuando aplica.
Sí. El Proyecto Final puede adaptarse a APIs internas, webhooks, BFFs, servicios cloud, backends serverless, integraciones SaaS o plataformas edge.
Sí, esta formación puede ser bonificable hasta el 100% a través de FUNDAE, siempre que la empresa disponga de crédito formativo suficiente y se cumplan los requisitos de comunicación, asistencia y documentación exigidos.
No. Aunque encaja muy bien con Cloudflare Workers, también puede ejecutarse en Node.js, Bun, Deno, Vercel, AWS Lambda, Fastly Compute, Netlify, Google Cloud Run y otros entornos.
Sí, es muy recomendable. Hono puede usarse con JavaScript, pero su mayor valor aparece cuando se trabaja con TypeScript, tipos, validación y RPC.
Sí. El curso compara Hono con Express, Fastify, NestJS, Elysia y frameworks full stack para saber cuándo elegir cada opción.
Sí. Se trabajan Basic Auth, Bearer Auth, JWT, cookies, sesiones, CSRF, roles, autorización y opciones de integración con proveedores externos.
Sí. El curso incluye generación de documentación OpenAPI, validación, contratos, ejemplos, tags, errores y publicación de documentación interactiva.
Hono RPC permite compartir tipos de la API entre servidor y cliente TypeScript, facilitando clientes tipados e inferencia de entradas y salidas.
Sí. Se trabaja integración con SQL, ORMs o query builders como Drizzle, Prisma o Kysely, además de bases serverless y servicios edge-friendly.
Sí. Se trabajan tests unitarios, integración, endpoints, middlewares, validación, errores y pruebas automatizadas con Vitest u otras herramientas compatibles.
Sí. Se trabajan despliegues en Node.js, Bun, Deno, Cloudflare Workers, Vercel, AWS Lambda, Fastly y otras plataformas según el caso.
Sí. Hono es muy adecuado para microservicios, APIs internas, BFFs, webhooks, gateways ligeros y servicios serverless.
Sí. Se abordan router, middlewares, caché, ETag, latencia, cold starts, payloads, consultas externas, logs y optimización real basada en métricas.
El curso se centra en backend y APIs, pero incluye consumo desde frontend TypeScript mediante RPC, además de HTML/JSX y SSR ligero cuando aplica.
Sí. El Proyecto Final puede adaptarse a APIs internas, webhooks, BFFs, servicios cloud, backends serverless, integraciones SaaS o plataformas edge.
Sí, esta formación puede ser bonificable hasta el 100% a través de FUNDAE, siempre que la empresa disponga de crédito formativo suficiente y se cumplan los requisitos de comunicación, asistencia y documentación exigidos.
Diseñemos hoy el curso que tu empresa necesita
Cuéntanos tus objetivos de negocio y prepararemos una propuesta formativa bonificable totalmente ad hoc
Seguridad desde el diseño Se incorporan CORS, JWT, Bearer Auth, Basic Auth, cookies, CSRF, secure headers, body limits, autorización, errores seguros y gestión de secretos.
3
Preparado para producción No se queda en endpoints básicos. Incluye testing, logging, observabilidad, rendimiento, CI/CD, despliegue, documentación, arquitectura modular y troubleshooting.
4
Ideal para edge y serverless Hono encaja muy bien en plataformas edge y funciones serverless. El curso enseña patrones específicos para evitar problemas de conexiones, cold starts, variables y límites de runtime.
5
Documentación y contratos profesionales Con OpenAPI, validadores y clientes RPC, los equipos pueden crear APIs documentadas, tipadas y fáciles de consumir por frontends, integraciones o terceros.
Después de la formación en directo, los alumnos podrán acceder a ejercicios prácticos para aplicar lo trabajado en clase y consolidar el aprendizaje con actividades guiadas.
Acceso a las grabaciones
Los alumnos podrán revisar las sesiones grabadas para repasar conceptos clave, recuperar explicaciones concretas o reforzar aquellos contenidos que necesiten después de la clase en directo.
Recursos formativos
Materiales, sesiones grabadas y documentación de apoyo quedan centralizados en la plataforma para que el equipo pueda consultarlos durante y después de la formación.
Confirmación de asistencia
La plataforma permite registrar y confirmar la asistencia de los participantes, facilitando el seguimiento de la formación y la gestión documental necesaria para la bonificación FUNDAE.
Ejercicios prácticos
Después de la formación en directo, los alumnos podrán acceder a ejercicios prácticos para aplicar lo trabajado en clase y consolidar el aprendizaje con actividades guiadas.
Practica y mejora con nuestra plataforma
Una plataforma practica, con IA integrada y pensada para que mejores desarrollando. Se adapta a tu ritmo, te corrige al instante y te muestra tu progreso real.
Correccion magica
Feedback inteligente
Aprende de cada acierto y fallo con explicaciones claras
Los perfiles de arquitectura y plataforma aprenderán a desplegar Hono en distintos runtimes, diseñar patrones portables, gestionar variables de entorno, observabilidad, seguridad, CI/CD, rendimiento y estrategias de despliegue en edge y serverless.
Equipos que construyen APIs internas y microservicios
Los equipos que necesitan servicios pequeños, rápidos y mantenibles podrán usar Hono para construir APIs REST, gateways ligeros, servicios de integración, microservicios, webhooks, colas HTTP y endpoints especializados.
Desarrolladores interesados en Cloudflare Workers, Bun o Deno
El curso resulta especialmente útil para quienes quieren aprovechar runtimes modernos y plataformas edge. Se trabajan diferencias prácticas entre Cloudflare Workers, Bun, Deno, Node.js, Vercel, Fastly y AWS Lambda.
Tech leads y responsables de arquitectura backend
Los tech leads podrán definir estándares de proyecto, estructura modular, validación, errores, seguridad, documentación OpenAPI, testing, logging, versionado de APIs y criterios para elegir Hono frente a frameworks más pesados.