Elegir entre un monolito, un monolito modular y microservicios es una de las primeras decisiones de arquitectura que analizamos con los clientes en cualquier nuevo proyecto de desarrollo de aplicaciones web, porque equivocarse sale caro de deshacer más adelante. Esta guía expone lo que cuesta realmente operar cada opción, cuándo la balanza se inclina a favor de dividir en servicios y la matriz de decisión que utilizamos con equipos de producto de EE. UU. y la UE.
TL;DR: opte por defecto por un monolito modular
Opte por defecto por un monolito modular: una única aplicación desplegable con límites de dominio limpios y aplicados de forma estricta. Encaja con la mayoría de las aplicaciones web, incluidos SaaS B2B, marketplaces y portales empresariales. Pase a microservicios solo cuando tenga un motivo concreto. Normalmente eso significa más de 20 ingenieros, perfiles de escalado por dominio que realmente se han distanciado o cadencias de despliegue independientes que un monolito no puede expresar, y suele aparecer a partir de unos 10M de solicitudes al día.
El debate de arquitectura de 2016–2020 proclamaba que los monolitos habían muerto y que los microservicios eran el futuro. La dura experiencia operativa ha corregido en gran medida esa idea. Esta es la versión corta:
- Opte por defecto por un monolito modular. Módulos limpios, límites de dominio aplicados de forma estricta y un único pipeline de despliegue. Es el punto de partida adecuado para la inmensa mayoría de las aplicaciones web, incluidos SaaS B2B, marketplaces y portales empresariales.
- Extraiga servicios cuando tenga un motivo concreto. Perfiles de escalado distintos, cadencias de despliegue independientes o límites de propiedad entre equipos que un monolito no puede expresar con claridad. No antes.
- Los microservicios completos tienen sentido a escala. Piense en más de 20 ingenieros, más de 10M de solicitudes al día y SLA de servicio que realmente divergen. Por debajo de ese umbral, la sobrecarga solo lastra la velocidad de su equipo.
- Un monolito sin más no es motivo de vergüenza. Shopify, Stack Overflow y Basecamp alcanzaron miles de millones de dólares de ingresos con monolitos bien ajustados. La arquitectura solo es errónea si le impide hacer algo que necesita hacer.
Las tres opciones, definidas
Monolito tradicional
Una única aplicación desplegable. Toda la lógica de negocio, el acceso a datos y la presentación viven en una base de código y en un proceso. Todas las funcionalidades se publican juntas, la base de datos es compartida y escalar significa ejecutar más copias de toda la aplicación. Una aplicación Rails clásica es un monolito; también lo son un proyecto Django o un servicio Spring Boot.
Monolito modular
Sigue siendo un único binario desplegable, pero el código está dividido en módulos bien definidos. Cada módulo es dueño de su lógica de dominio, de su espacio de nombres en el esquema de la base de datos y de su interfaz pública. Los módulos se comunican entre sí mediante APIs internas del proceso o contratos de mensajes, en lugar de llamadas HTTP. La base de código se despliega de forma sencilla, pero está estructurada para que un módulo pueda extraerse más adelante como servicio propio. Es lo primero que elegimos en los proyectos de nuestro servicio de desarrollo de aplicaciones web para clientes de EE. UU. y la UE.
Microservicios
Un conjunto de servicios desplegables de forma independiente. Cada uno es dueño de un dominio acotado y se comunica con los demás por HTTP o a través de un message broker (Kafka, RabbitMQ, SQS). Cada uno tiene además su propia base de datos, su propio pipeline de CI/CD y su propia huella operativa. Si se hace bien, las grandes organizaciones publican rápido sin pisarse unas a otras. Si se hace demasiado pronto, se obtiene un monolito distribuido: todos los inconvenientes de ambos mundos y ninguna de las ventajas de ninguno.
Lo que un monolito moderno puede hacer realmente
La idea de que «monolito equivale a heredado» es, sobre todo, un artefacto de marketing de la era de Kubernetes. Así que seamos precisos sobre lo que un monolito moderno puede y no puede hacer.
Escalan horizontalmente
Ejecute cuatro copias de una aplicación Rails o Django detrás de un balanceador de carga y ya estará escalando horizontalmente. Eso funciona hasta que la base de datos se convierte en el cuello de botella. En ese punto se recurre a réplicas de lectura y a pooling de conexiones, no necesariamente a un nuevo servicio. Stack Overflow sirve miles de millones de páginas vistas con nueve servidores on-premise. El monolito nunca fue allí el cuello de botella; los verdaderos culpables eran cachés ausentes, índices ausentes y una disciplina laxa en las consultas.
Permiten iterar rápido
Un monolito tiene un pipeline de despliegue, un conjunto de pruebas de integración y un único lugar donde hacer grep cuando persigue un bug. Para un equipo de 3–15 ingenieros, eso es una ventaja real de coordinación. Cada sistema distribuido que añade multiplica los modos de fallo que debe monitorizar y los escenarios de rollback que debe ensayar.
Facilitan los límites de cumplimiento
La residencia de datos del RGPD, los registros de auditoría de HIPAA y los controles de SOC 2 son más fáciles de implementar dentro de una sola aplicación que de imponer en una malla de servicios. Se mantiene un único registro de auditoría, un único almacén de secretos y un único punto de terminación TLS. Consulte los patrones que usamos en cómo construir un SaaS multi-tenant; el multi-tenancy es totalmente viable dentro de un monolito modular.
Dónde tienen dificultades reales los monolitos
Aun así, existen limitaciones reales. Si su servicio de checkout tiene que soportar 50 veces el tráfico de su módulo de informes, escalar toda la aplicación solo desperdicia recursos. Si su pipeline de inferencia de ML funciona con requisitos completamente distintos (GPU, Python, su propia cadencia de despliegue), mantenerlo en el mismo proceso resulta incómodo. Esos son los motivos correctos para extraer un servicio. La moda en ingeniería no lo es.
¿Cuándo compensan realmente los microservicios?
Los microservicios son la respuesta correcta en un puñado de escenarios. Así puede reconocerlos cuando se los encuentre.
Perfiles de escalado realmente distintos
Si su motor de recomendación de productos recibe 1,000 solicitudes por segundo en el pico mientras su API de ajustes de usuario recibe 5, no tiene sentido escalar ambos a la vez. Cuando puede medir esa diferencia en producción, y no solo esbozarla en una sesión de pizarra, sacar la ruta crítica a su propio servicio se amortiza sola. Para ver cómo las cargas de trabajo con mucha inferencia suelen justificar esa división, consulte el stack empresarial de agentes de IA de 2026.
Cadencias de despliegue independientes
Cuando distintos equipos de producto necesitan publicar varias veces al día sin coordinarse, un único pipeline de despliegue se convierte en un cuello de botella. Ese, y no el rendimiento bruto, fue el motivo original de Amazon para adoptar microservicios: la velocidad organizativa. Si su equipo de analítica y su equipo de facturación esperan continuamente a que se estabilice el código del otro antes de una versión, la arquitectura ha fabricado un problema de coordinación humana que un límite de servicio resolvería.
Dominios de fallo aislados
Un bug catastrófico en un monolito tumba toda la aplicación. En una arquitectura de microservicios, un bug en su servicio de notificaciones no tiene por qué arrastrar al checkout. Los circuit breakers, los bulkheads y la degradación controlada solo tienen sentido cuando existen límites de servicio donde aplicarlos. Para los flujos de altos ingresos, como los pagos, la API principal y la autenticación, esa garantía de aislamiento compensa el coste operativo.
Límites normativos y de residencia de datos
Una empresa de EE. UU. que atiende a clientes de la UE sujetos al RGPD puede necesitar de verdad que los datos residentes en la UE se procesen en un servicio desplegado y auditado por separado, no solo mediante un flag de configuración dentro de una aplicación compartida. El aislamiento del alcance de PCI DSS funciona igual. Los datos de titulares de tarjetas gestionados en su propio servicio, tras su propio límite de red, son arquitectónicamente más limpios que intentar reducir la superficie de un monolito.
Ejemplos reales: lo que nos enseñan los grandes sistemas
La teoría es útil. Los resultados en producción, mejores. Estos son cuatro casos bien documentados que ilustran cuándo compensó cada arquitectura y cuánto costó.
Netflix: la escala extrema justificó la inversión
Netflix migró de un monolito de envío de DVD a cientos de servicios independientes entre 2009 y 2015, a raíz de una corrupción de la base de datos en 2008 que dejó el servicio fuera de línea durante tres días. A la escala de Netflix (200 millones de suscriptores reproduciendo contenido simultáneamente), el escalado granular importaba de verdad: el servicio de codificación necesitaba instancias con GPU, el motor de recomendación necesitaba infraestructura de ML y la API de streaming necesitaba tiempos de respuesta inferiores al milisegundo en PoPs de todo el mundo. La inversión operativa fue enorme; Netflix tuvo que construir desde cero Hystrix, Chaos Monkey y una plataforma de observabilidad completa. La lección no es «haga lo que hizo Netflix», sino que Netflix tenía problemas de escalado medidos y concretos que hacían que los microservicios compensaran su coste antes de empezar la migración.
Amazon: el verdadero motor fue la velocidad organizativa
La descomposición en servicios de Amazon comenzó con un mandato interno de 2002: todos los equipos debían exponer sus datos y su funcionalidad mediante interfaces de servicio y comunicarse exclusivamente a través de ellas. El objetivo no era el rendimiento, sino permitir que cientos de equipos publicaran de forma independiente sin cuellos de botella en la coordinación de versiones. El efecto secundario arquitectónico fue AWS: cuando Amazon descompuso en servicios su propia infraestructura de cómputo, almacenamiento y bases de datos, esos servicios se convirtieron en productos vendibles. Si su organización no tiene el problema de coordinación entre equipos de Amazon a esa escala, no necesita la solución de Amazon.
Shopify: un monolito modular a escala de comercio
Shopify funcionó durante más de una década sobre un único monolito de Ruby on Rails, al servicio de millones de comerciantes y con decenas de miles de millones de GMV al año. Su enfoque fue deliberado: una fuerte inversión en diseño modular, colas de tareas en segundo plano, réplicas de lectura y un modelo de datos multi-tenant cuidadosamente estructurado. Con el tiempo sí extrajeron algunos servicios (en concreto, el renderizado del escaparate y el checkout), pero el núcleo de la plataforma de comercio siguió siendo un monolito bien mantenido. La lección: el techo de rendimiento de un monolito bien ajustado es mucho más alto de lo que la mayoría de los equipos de ingeniería alcanzará jamás.
Stack Overflow: nueve servidores, miles de millones de páginas vistas
Stack Overflow funciona con nueve servidores on-premise por decisión propia y atiende miles de millones de solicitudes al mes. El equipo de ingeniería atribuye esta eficiencia a una caché agresiva, a la optimización de consultas y a un monolito maduro. Cuando se necesitó más capacidad, el equipo perfiló primero: los cuellos de botella casi siempre eran consultas lentas concretas, índices ausentes o lecturas críticas sin caché, no el monolito. Es el punto de calibración más útil para cualquier equipo que planee microservicios «para escalar» antes de haber medido dónde está su techo real.
Coste, tamaño del equipo y carga operativa
Los microservicios no son gratis. Cada servicio que añade multiplica el coste de infraestructura y de personal. Estas son las cuentas, sin maquillar.
Coste de infraestructura
Cada servicio necesita su propio cómputo (contenedor, Lambda o VM), su propia base de datos o espacio de nombres de base de datos, su propia integración con el gestor de secretos, su propia regla de enrutamiento en el balanceador de carga o el API gateway, su propia entrada en la agregación de logs y su propio monitor de health checks. Con diez servicios, paga diez de cada. En AWS o GCP, un monolito modular suele costar un 60–80 % menos al mes en infraestructura que una malla de microservicios equivalente con el mismo tráfico.
Coste de observabilidad
Un monolito falla con un stack trace en un único flujo de logs. Un sistema distribuido falla con trazas parciales repartidas entre cinco servicios, dos colas asíncronas y una capa de caché. Por eso el trazado distribuido (Jaeger, Tempo, AWS X-Ray), la agregación estructurada de logs (Loki, Datadog, CloudWatch) y los paneles de salud de los servicios dejan de ser un extra y pasan a ser un requisito. Presupueste un ingeniero de plataforma dedicado más $2,000–8,000/mes en herramientas SaaS en cuanto un equipo opere más de 10 servicios.
Tamaño de equipo necesario
La regla de las dos pizzas de Amazon (6–10 ingenieros por servicio) es el mínimo operativo para mantener un servicio sin cambios de contexto constantes. Con menos de 20–30 ingenieros en total, los microservicios obligan a cada ingeniero a encargarse de varios servicios a la vez, que es justo la sobrecarga de coordinación que la arquitectura debía eliminar. Para ver cómo estas decisiones de arquitectura tempranas influyen en la fiabilidad del producto, que a su vez impulsa la retención, consulte la guía práctica para reducir el churn en SaaS.
Estructura del equipo y ley de Conway
La observación que hizo Melvin Conway en 1967 sigue vigente: toda organización que diseña un sistema producirá un diseño cuya estructura refleja la propia estructura de comunicación de la organización. En la práctica, esto funciona en ambos sentidos. Si dibuja los límites de los servicios en una pizarra pero deja a un solo equipo responsable de todos ellos, obtendrá un monolito distribuido: servicios que se despliegan por separado pero que aun así deben coordinar cada versión, porque las personas que los mantienen hablan entre sí constantemente. Lo contrario también se cumple: los equipos organizados en torno a una propiedad clara de los dominios tienden a producir límites de módulo limpios incluso dentro de una única base de código monolítica, porque el código sigue el organigrama, lo planifique usted o no.
La investigación independiente confirma lo que cuesta que el organigrama y la arquitectura no coincidan. Las encuestas del sector sobre la adopción de microservicios han constatado una y otra vez que la depuración y el triaje de incidentes llevan bastante más tiempo en los sistemas distribuidos que en un monolito comparable, porque un único error visible para el usuario puede originarse en cualquiera de varios servicios y hay que rastrearlo a través de los límites entre procesos. Por otra parte, los estudios de consultoras especializadas en eficacia de ingeniería —incluida la guía publicada por Thoughtworks sobre la descomposición en servicios— advierten de forma sistemática que las organizaciones de menos de unos 50 ingenieros rara vez obtienen una ganancia neta de productividad con los microservicios, porque el coste de coordinación de mantener los contratos entre servicios supera la ventaja en cadencia de versiones con esa plantilla. Tome estas cifras como orientativas, no como dogma —las metodologías varían—, pero coinciden con el patrón operativo que vemos en los proyectos con clientes: las decisiones de arquitectura que ignoran la estructura del equipo generan trabajo, independientemente del lado de la línea monolito/microservicios en el que caigan.
| Criterio | Monolito | Monolito modular | Microservicios |
|---|---|---|---|
| Complejidad del despliegue | Baja | Baja | Alta |
| Coste de infraestructura (mismo tráfico) | El más bajo | El más bajo | 2–5 veces mayor |
| Sobrecarga de observabilidad | Mínima | Mínima | Considerable |
| Escalabilidad horizontal | De grano grueso | De grano grueso | De grano fino |
| Despliegues independientes por equipo | No | Parcial | Sí |
| Equipo mínimo para operarlo bien | 3–5 ingenieros | 5–15 ingenieros | 20+ ingenieros |
| Tiempo hasta el primer despliegue en producción | 1–2 semanas | 1–3 semanas | 4–8 semanas |
Arquitectura de datos y contrapartidas de consistencia
Lo más difícil de una migración a microservicios rara vez es el servicio en sí: es dividir la base de datos. Merece su propia sección porque provoca más migraciones fallidas que cualquier otro factor.
Monolito: base de datos compartida y garantías ACID
Un monolito suele utilizar una única base de datos relacional. Esto le ofrece transacciones ACID entre límites de dominio sin coste adicional. Cuando un pago se completa y un pedido se confirma en la misma solicitud, ambas escrituras se producen dentro de una sola transacción de base de datos. Si cualquiera de ellas falla, todo se revierte. Las consultas entre dominios también son sencillas: un único JOIN de SQL es mucho más barato que dos llamadas entre servicios con agregación en el lado del cliente.
Microservicios: una base de datos por servicio y consistencia eventual
El principio de los microservicios es una base de datos por servicio: el servicio es dueño de sus datos y solo los expone a través de su API. Esto le aporta aislamiento del esquema y una evolución independiente del esquema, pero elimina las garantías ACID entre los límites de los servicios. Cuando un servicio de pagos y un servicio de pedidos son dueños cada uno de sus datos, y la escritura del pago tiene éxito pero la del pedido falla, tiene un problema de consistencia distribuida que debe resolverse de forma explícita. Los patrones habituales son la coreografía de sagas (cada servicio publica eventos que desencadenan el siguiente paso) y la orquestación de sagas (un coordinador central secuencia los pasos). Ambos añaden una complejidad considerable de implementación y depuración que, sencillamente, no existe en un monolito.
Recomendaciones prácticas
Empiece con una base de datos compartida, incluso dentro de un monolito modular. Imponga los límites de dominio mediante espacios de nombres de esquema —esquemas de Postgres separados por módulo— y API de módulo estrictas, no con instancias de base de datos separadas. Extraiga la base de datos solo cuando extraiga el servicio, y solo después de que el límite del servicio haya sido estable en producción el tiempo suficiente como para confiar en él. Dividir una base de datos de forma especulativa, antes de extraer un servicio, le trae todo el dolor de la consistencia sin ninguna de las ventajas de la independencia de despliegue.
Cómo escalar una aplicación web correctamente
Antes de elegir una arquitectura para una escala que todavía no tiene, recorra estas palancas en orden. La mayoría de las aplicaciones nunca necesitan pasar del paso tres.
1. Escalado vertical y optimización de consultas
Duplique el tamaño de la instancia de base de datos. Añada un índice a la consulta lenta. Active el pooling de conexiones (PgBouncer, RDS Proxy). Es ingeniería gratuita o casi gratuita, y suele aportar 5–10 veces más margen de capacidad. La mayoría de las aplicaciones que supuestamente «necesitan microservicios para escalar» en realidad necesitan un índice en la base de datos y una caché Redis.
2. Escalado horizontal de la aplicación
Ejecute varias instancias de su monolito detrás de un balanceador de carga. Añada réplicas de lectura para las cargas de trabajo con muchas lecturas. Utilice una CDN para descargar los recursos estáticos y las respuestas de API en caché. Un único proceso de Rails o Node.js con 4 vCPU gestiona ~500 solicitudes por segundo. Ocho instancias detrás de un balanceador de carga gestionan 4,000. A ese techo se llega despacio.
3. Caché y colas asíncronas
Ponga Redis o Memcached delante de sus rutas de lectura más solicitadas. Pase a una cola de trabajos en segundo plano (Sidekiq, Celery, Bull) todo lo que no necesite ser síncrono: correos electrónicos, webhooks, generación de informes, llamadas a API de terceros. Sacar ese trabajo de la ruta de la solicitud elimina toda una clase de latencia de cola por solicitudes lentas que hace que su p95 parezca terrible, y no requiere ningún cambio de arquitectura.
4. Extraiga los servicios de uno en uno
Cuando una ruta crítica concreta sea realmente un cuello de botella y haya agotado los pasos anteriores, extraiga ese servicio con el patrón strangler fig. Dirija el tráfico nuevo al servicio mientras el monolito sigue atendiendo el resto, y migre de forma incremental. No intente una reescritura big-bang de monolito a microservicios: la tasa de fracaso es alta y el coste, enorme.
Migración: del monolito a los microservicios
Si ha decidido que una parte concreta de su sistema realmente necesita convertirse en un servicio propio, así puede ejecutar esa migración sin una reescritura big-bang, que en la práctica tiene una tasa de fracaso muy alta.
El patrón strangler fig
Toma su nombre de un árbol que crece alrededor de su huésped y lo sustituye poco a poco, y es el enfoque estándar para extraer servicios de forma incremental:
- Identifique una costura. Busque un módulo con un límite de dominio claro —pagos, notificaciones, búsqueda— cuya interfaz con el resto del monolito ya esté bien definida y sea estable.
- Construya el nuevo servicio. Implemente la misma funcionalidad de forma independiente, con su propio espacio de nombres de base de datos y su propio pipeline de despliegue.
- Enrute el tráfico en el borde. Utilice un API gateway o una regla del balanceador de carga para enviar una parte de las solicitudes al nuevo servicio. El monolito sigue atendiendo el resto.
- Migre de forma incremental. Traslade el tráfico gradualmente —1 %, 10 %, 50 %, 100 %— con observabilidad en cada paso. Revierta al instante si las tasas de error se desvían de la línea base del monolito.
- Elimine el código antiguo. Cuando el servicio gestione el 100 % del tráfico y haya sido estable durante al menos un ciclo de guardia, elimine el módulo del monolito y limpie el esquema de la base de datos.
Antipatrones que conviene evitar
- Monolito distribuido. Los servicios que comparten una base de datos, o que se llaman entre sí de forma síncrona en cada solicitud, no le dan ninguna de las ventajas de los microservicios y sí toda su complejidad. Si los servicios no pueden desplegarse de forma independiente, no son microservicios: son un monolito con un peaje de red.
- Reescritura big-bang. Reescribir de cero un sistema que funciona como microservicios, todo de una vez, tiene una tasa de éxito muy baja. El monolito contiene años de lógica de negocio acumulada, casos límite y tratamiento de requisitos de cumplimiento que son invisibles hasta que fallan en el nuevo sistema.
- Extracción prematura. Extraer un servicio antes de que su límite de dominio sea estable implica que tendrá que refactorizar el contrato una y otra vez, lo que sale caro. Espere a que el dominio sea realmente estable en producción y, entonces, extraiga.
- Sin observabilidad antes de la división. Si no puede ver trazas distribuidas, agregar logs de todos los servicios y obtener las tasas de error por servicio, está volando a ciegas. Instrumente antes de extraer, no después.
Matriz de decisión
Utilice esta matriz cuando vaya a tomar realmente la decisión. Puntúe cada fila según la situación en la que se encuentra ahora, no según la empresa que espera ser dentro de tres años.
| Criterio | Elija un monolito modular si… | Plantéese los microservicios si… |
|---|---|---|
| Tamaño del equipo | Menos de 20 ingenieros | 20+ ingenieros repartidos en varios squads de producto |
| Patrón de tráfico | Uniforme o de bajo volumen hoy | Picos de carga medidos y distintos por dominio |
| Cadencia de despliegue | Uno o dos equipos, versiones coordinadas | Varios equipos que necesitan cadencias independientes |
| Aislamiento por cumplimiento | RGPD/SOC 2 estándar, asumibles en una sola aplicación | Ámbito de datos del titular de la tarjeta de PCI DSS o residencia de datos estricta |
| Madurez de DevOps | Sin ingeniero de plataforma dedicado | Equipo de plataforma/SRE ya en marcha |
| Combinación de tecnologías | Un lenguaje/runtime principal | Necesidad real de runtimes mixtos (p. ej., un servicio de ML en GPU) |
| Requisito de tolerancia a fallos | Caída total aceptable en incidentes poco frecuentes | Se requiere degradación parcial (el checkout debe sobrevivir a una caída de la analítica) |
Tendencias de arquitectura en 2026
Algunos cambios del panorama de 2026 merecen tenerse en cuenta al tomar una nueva decisión de arquitectura.
El renacimiento del monolito modular
Una encuesta de la CNCF de 2025 reveló que el 42 % de las organizaciones que adoptaron microservicios han vuelto a consolidar desde entonces algunos servicios en unidades desplegables más grandes. Los principales motivos fueron la complejidad de la depuración, la latencia de red y una sobrecarga operativa que no aportaba un valor de negocio proporcional. El monolito modular —un término que en 2018 tenía una connotación casi de disculpa— es hoy una elección arquitectónica deliberada y generalizada, no una concesión.
La inferencia de IA como límite natural de servicio
La inferencia de aprendizaje automático es una de las pocas cargas de trabajo en las que extraer un microservicio casi siempre está justificado: se ejecuta en hardware distinto (GPU o NPU), tiene una cadencia de despliegue diferente (las versiones de los modelos son independientes de las versiones de la aplicación) y un perfil de escalado notablemente distinto. Si su producto llama a un LLM o ejecuta inferencia de modelos en el dispositivo, tratar el endpoint de inferencia como un servicio aparte —aunque todo lo demás sea un monolito— es un patrón limpio y práctico que no obliga a comprometerse con una arquitectura completa de microservicios.
La ingeniería de plataformas sustituye a la complejidad del service mesh
La adopción del service mesh (Istio, Linkerd) alcanzó su pico y luego decayó: la mayoría de los equipos comprobaron que el peso operativo de una capa de mesh —configuración de mTLS, proxies sidecar, CRDs personalizados— superaba sus ventajas a su escala. El patrón que la sucede es la ingeniería de plataformas: centralizar los pipelines de CI/CD, la gestión de secretos, la configuración de observabilidad y las plantillas de servicio en una plataforma interna para desarrolladores, de modo que cada equipo de producto no tenga que resolver de nuevo esos problemas para cada servicio nuevo. Si planifica microservicios a escala, presupueste un equipo de plataforma antes de empezar a multiplicar servicios.
Serverless para cargas de trabajo esporádicas y orientadas a eventos
Las funciones como servicio (AWS Lambda, Cloudflare Workers, Google Cloud Run functions) han madurado hasta el punto de ser un destino de despliegue viable para muchos casos de uso de microservicios, en concreto controladores de eventos, webhooks, tareas programadas y procesamiento en segundo plano con tráfico irregular o de bajo volumen. Para los equipos que quieren aislamiento a nivel de servicio sin la sobrecarga de Kubernetes, merece la pena evaluar serverless antes de recurrir a una orquestación completa de contenedores.
Preguntas frecuentes
¿Debe una startup usar microservicios?
Casi nunca al principio. Los microservicios multiplican la superficie operativa: descubrimiento de servicios, trazado distribuido, pipelines de CI/CD independientes y un equipo lo bastante grande para encargarse de cada servicio. La limitación de una startup es lanzar producto y aprender rápido, no la flexibilidad de la infraestructura. Empiece con un monolito modular; extraiga servicios cuando un límite concreto de escalado o de propiedad le obligue a ello.
¿Qué es un monolito modular?
Un monolito modular es una única aplicación desplegable dividida internamente en módulos bien definidos y débilmente acoplados, cada uno dueño de su propia lógica de dominio, de su espacio de nombres de esquema de base de datos y de su superficie de API pública. Se despliega como un solo proceso, pero está estructurado para que los módulos puedan extraerse más adelante como servicios independientes con una refactorización mínima. Es el punto óptimo para la mayoría de los equipos de menos de 50 ingenieros.
¿Cuándo compensan los microservicios?
Los microservicios compensan cuando: (1) distintas partes del sistema tienen perfiles de escalado realmente diferentes —el checkout soporta 10 veces la carga del panel de administración—; (2) equipos independientes necesitan desplegar sin coordinar versiones; (3) un servicio concreto requiere otro stack tecnológico, otro SLA u otro límite de cumplimiento. Si hoy no se da ninguna de estas condiciones, la sobrecarga de los microservicios es puro coste.
¿Son los microservicios más escalables que un monolito?
No automáticamente. Un monolito bien ajustado en una infraestructura cloud moderna gestiona millones de solicitudes al día con escalado horizontal, pooling de conexiones y réplicas de lectura. Los microservicios permiten un escalado de grano fino de las rutas críticas, pero esa ventaja solo se materializa cuando los distintos servicios tienen realmente perfiles de tráfico diferentes. Muchos equipos añaden la complejidad de los microservicios antes de tener el tráfico que la justificaría.
¿Qué tamaño debe tener el equipo para operar microservicios?
La regla de las dos pizzas de Amazon es una guía útil: cada servicio debería poder estar a cargo de un equipo de 6–10 ingenieros. En la práctica necesita al menos un ingeniero de DevOps o de plataforma dedicado, cobertura de SRE, herramientas de observabilidad y suficientes desarrolladores para mantener cada servicio sin cambios de contexto constantes. Con menos de 20–30 ingenieros en total, los microservicios suelen crear más sobrecarga de coordinación de la que eliminan.
¿Puedo migrar de un monolito a microservicios más adelante?
Sí, y es el camino recomendado. Construya desde el principio un monolito modular con límites de dominio limpios y, más adelante, extraer un servicio será un esfuerzo acotado: mover el código de un módulo, dividir sus tablas de base de datos y añadir un contrato de API. El patrón strangler fig —dirigir el tráfico de forma incremental a un nuevo servicio mientras el monolito atiende el resto— está probado a fondo para esta migración. No diseñe para microservicios desde el primer día salvo que ya tenga el equipo y el tráfico que lo exigen.
¿Qué es la consistencia eventual y por qué importa en los microservicios?
En un monolito con una base de datos compartida, las operaciones entre distintas partes de la aplicación participan en transacciones ACID: garantías de todo o nada que nunca dejan los datos en un estado parcial. En una arquitectura de microservicios, cada servicio es dueño de su base de datos, por lo que se pierde esa garantía entre los límites de los servicios. En su lugar, se obtiene consistencia eventual: el sistema convergerá a un estado consistente si se le da tiempo suficiente y no hay más actualizaciones, pero los estados intermedios pueden ser visibles. Gestionarlo correctamente exige patrones explícitos: el patrón saga, el patrón outbox y event sourcing. Subestimar esta complejidad es una de las causas más habituales de las migraciones a microservicios problemáticas.
¿Qué es el diseño guiado por el dominio y qué relación tiene con los límites de los servicios?
El diseño guiado por el dominio (Domain-Driven Design, DDD) es un enfoque de diseño de software que estructura el código en torno a los dominios de negocio y sus límites explícitos, llamados contextos delimitados (bounded contexts). Cada contexto delimitado —pagos, inventario, cuentas de usuario— tiene su propio modelo, su propio lenguaje y la propiedad de sus datos. En una arquitectura de microservicios, los contextos delimitados se corresponden directamente con los límites de los servicios: cada servicio es dueño de su contexto delimitado y solo lo expone a través de una API. En un monolito modular, los contextos delimitados se corresponden con módulos. DDD le proporciona el lenguaje y las herramientas de modelado para definir esos límites con rigor antes de comprometerse con cualquier topología de despliegue, y por eso aparece en casi todos los recursos serios sobre diseño de microservicios.
Última actualización: 4 de septiembre de 2026. Recomendaciones de arquitectura basadas en proyectos en producción realizados para clientes de EE. UU. y la UE entre 2022 y 2026. Las cifras de costes son estimaciones; el gasto real en infraestructura varía según el proveedor cloud, la región y el perfil de tráfico.