DEV Community

Cover image for ¿Qué es la arquitectura composable? La guía MACH y API-first
Roobia
Roobia

Posted on • Originally published at apidog.com

¿Qué es la arquitectura composable? La guía MACH y API-first

La arquitectura componible es una forma de construir sistemas de software a partir de componentes independientes, intercambiables y de “mejor de su clase” que se comunican entre sí mediante APIs, en lugar de depender de una gran plataforma todo en uno. Es el concepto más amplio que engloba el movimiento headless, y está estrechamente ligado a la MACH Alliance, el organismo industrial neutral de proveedores que promueve la tecnología empresarial abierta y componible.

Prueba Apidog hoy

Una rápida aclaración primero

La palabra “componible” aparece en tres contextos distintos. Para evitar confusiones:

  • Arquitectura componible: enfoque de diseño de software. Ensamblas una aplicación a partir de capacidades de negocio separadas, integradas mediante APIs.
  • Infraestructura componible: concepto de hardware y centro de datos. Computación, almacenamiento y red se agrupan y asignan dinámicamente a cargas de trabajo.
  • Componibilidad DeFi: concepto de blockchain, también llamado “legos de dinero”. Los contratos inteligentes se combinan para crear nuevos productos financieros.

En esta guía, “componible” se refiere siempre a arquitectura de software.

Qué significa realmente la arquitectura componible

Un sistema componible se construye con unidades modulares y autónomas. Cada unidad posee una función de negocio completa, expone una API y puede reemplazarse sin reconstruir todo el sistema.

La unidad clave se llama capacidad de negocio empaquetada, o PBC por sus siglas en inglés. Gartner define las PBC como capacidades desplegables de forma independiente que incluyen datos, lógica y procesos de negocio autónomos, e interactúan con otras aplicaciones mediante APIs y eventos.

Ejemplos de PBC:

  • Pago: métodos de pago, fraude, reembolsos y disputas.
  • Búsqueda: indexación, ranking y consultas.
  • Inventario: disponibilidad, reservas y movimientos de stock.
  • Identidad: usuarios, sesiones, permisos y autenticación.

La regla práctica: una PBC debe exponer una API de negocio, no una tabla de base de datos en bruto.

Por ejemplo, en lugar de que otros servicios consulten directamente una tabla payments, una PBC de pagos debería exponer operaciones como:

POST /payments
GET /payments/{paymentId}
POST /payments/{paymentId}/refunds
GET /payments/{paymentId}/disputes
Enter fullscreen mode Exit fullscreen mode

Así, el resto del sistema depende del contrato de API, no de la implementación interna.

Componible vs monolito

Un monolito agrupa todas las capacidades en una aplicación desplegable, normalmente con una base de datos compartida. Es rápido para empezar, pero se vuelve más difícil de cambiar a medida que crece.

La arquitectura componible separa esas capacidades para que cada una pueda evolucionar por separado. Si ya conoces la discusión entre monolito versus microservicios, lo componible es el mismo cambio visto desde el dominio de negocio: los microservicios son una descomposición técnica; las PBC son una descomposición de capacidades de negocio.

Dimensión Monolito Arquitectura componible
Unidad de cambio Toda la aplicación Una PBC
Datos Base de datos compartida Cada capacidad posee sus datos
Elección de proveedor Una plataforma completa Mejor herramienta por capacidad
Front end Acoplado al back end Desacoplado y multicanal
Integración Llamadas internas APIs y eventos
Riesgo de dependencia Alto Menor, por componentes reemplazables

La compensación es clara: ganas flexibilidad y capacidad de reemplazo, pero introduces más piezas que integrar, monitorear, versionar y operar.

MACH: el estándar al que la mayoría se refiere

Cuando los equipos hablan de arquitectura componible, normalmente se refieren a una pila alineada con los principios MACH. MACH es un acrónimo promovido por la MACH Alliance desde 2020:

  • M — Microservicios: capacidades pequeñas, independientes y desplegables por separado.
  • A — API-first: cada función se expone mediante una API estable.
  • C — Cloud-native: componentes diseñados para la nube, escalado elástico y servicios gestionados.
  • H — Headless: el front end está separado del back end.

No son sinónimos:

  • Headless es una parte de MACH.
  • MACH es una forma específica de construir sistemas componibles.
  • Componible es el concepto general.

La columna vertebral API-first

En una arquitectura componible, la API es la capa de integración que mantiene unido el sistema.

En un monolito, dos módulos pueden compartir base de datos o llamarse directamente. En un sistema componible, ese atajo desaparece. Cada componente debe comunicarse mediante contratos explícitos.

Por eso el desarrollo API-first es fundamental.

Un flujo API-first práctico se ve así:

  1. Define el dominio de negocio.
  2. Diseña el contrato OpenAPI.
  3. Revisa el contrato con consumidores y proveedores.
  4. Publica un mock server.
  5. Implementa el backend contra el contrato.
  6. Ejecuta pruebas automatizadas en CI.
  7. Versiona los cambios de forma controlada.
  8. Documenta la API para equipos internos o externos.

Ejemplo mínimo de contrato para una PBC de pagos:

openapi: 3.0.3
info:
  title: Payments API
  version: 1.0.0

paths:
  /payments:
    post:
      summary: Crear un pago
      requestBody:
        required: true
        content:
          application/json:
            schema:
              type: object
              required:
                - amount
                - currency
                - customerId
              properties:
                amount:
                  type: number
                  example: 49.99
                currency:
                  type: string
                  example: EUR
                customerId:
                  type: string
                  example: cus_123
      responses:
        "201":
          description: Pago creado
          content:
            application/json:
              schema:
                type: object
                properties:
                  paymentId:
                    type: string
                    example: pay_123
                  status:
                    type: string
                    example: authorized
Enter fullscreen mode Exit fullscreen mode

Cuando el front end es headless y las capacidades son intercambiables, la API es el producto. Si el contrato está mal diseñado, todos los consumidores lo sufrirán.

Beneficios y compensaciones

Beneficios

  • Mejor de su clase: eliges la herramienta más potente para cada capacidad.
  • Cambio independiente: actualizas o reemplazas una PBC sin tocar todo el sistema.
  • Menos dependencia de proveedor: reduces el riesgo de quedar atrapado en una sola plataforma.
  • Equipos paralelos: distintos equipos pueden trabajar sobre capacidades desacopladas.
  • Multicanal: las mismas APIs sirven a web, móvil, kioscos, voz u otros clientes.

Costos

  • Sobrecarga de integración: más componentes implican más conexiones.
  • Disciplina de contratos: un cambio incompatible en una API puede romper muchos consumidores.
  • Complejidad operativa: autenticación, observabilidad, versionado y pruebas se distribuyen.
  • Diseño inicial: debes invertir más tiempo en límites, contratos y responsabilidades.

La arquitectura componible es útil cuando necesitas flexibilidad, escala y múltiples canales. Puede ser excesiva si un monolito limpio resuelve bien el problema.

Dónde encaja Apidog: el pilar API-first

Apidog no convierte por sí solo tu arquitectura en componible. No es un CMS, motor de comercio, gateway de APIs ni plataforma MACH.

Su papel está en la A de MACH: API-first.

Como la API es la interfaz entre componentes independientes, el contrato debe ser correcto, verificable y fácil de consumir. Apidog ayuda a diseñar, probar, simular y documentar esos contratos.

Casos prácticos:

  • Diseño primero: define la API de cada capacidad como contrato OpenAPI antes de implementar.
  • Mock servers: permite que front ends, integraciones o socios trabajen contra una API simulada mientras el backend se desarrolla. Más contexto: mock API.
  • Pruebas headless: ejecuta pruebas de API desde CLI directamente en CI, sin depender de una interfaz gráfica.
  • Gestión desde herramientas: mediante MCP, puedes impulsar el proyecto de API desde un agente de IA o un IDE.

Un flujo típico para una PBC sería:

# 1. Diseñar contrato OpenAPI
# 2. Publicar mock server
# 3. Compartir documentación con consumidores
# 4. Implementar backend
# 5. Ejecutar pruebas de API en CI
Enter fullscreen mode Exit fullscreen mode

Si tu sistema sigue el modelo API-es-el-producto, esta capa de calidad mantiene los contratos bajo control. Puedes descargar Apidog para diseñar y simular un contrato antes de que exista el backend.

Cuándo adoptar la arquitectura componible

Considera una arquitectura componible si se cumplen varias de estas condiciones:

  • Necesitas atender varios canales: web, móvil, tienda física, voz u otros.
  • Diferentes capacidades cambian a ritmos muy distintos.
  • Quieres elegir proveedores de “mejor de su clase” por capacidad.
  • El vendor lock-in es un riesgo real para el negocio.
  • Tienes equipos capaces de mantener contratos de API, pruebas e integración continua.
  • Necesitas reemplazar componentes sin detener toda la plataforma.

Evítala o retrásala si:

  • Estás lanzando un único producto con un equipo pequeño.
  • El dominio aún cambia demasiado rápido.
  • No tienes madurez operativa para monitoreo, trazabilidad y CI/CD.
  • Un monolito modular puede resolver el problema con menos coste.

Una buena estrategia es empezar con límites claros dentro de un monolito modular y extraer PBCs cuando haya razones reales para hacerlo.

Checklist de implementación

Antes de separar una capacidad en una PBC, valida lo siguiente:

  • [ ] Tiene una responsabilidad de negocio clara.
  • [ ] Posee sus propios datos.
  • [ ] Expone una API de negocio estable.
  • [ ] No requiere acceso directo a tablas de otros componentes.
  • [ ] Tiene pruebas de contrato.
  • [ ] Tiene documentación consumible por otros equipos.
  • [ ] Puede desplegarse de forma independiente.
  • [ ] Tiene métricas, logs y trazas.
  • [ ] Tiene una estrategia de versionado.
  • [ ] Tiene propietarios claros.

Si varios puntos fallan, probablemente aún no estás listo para convertir esa parte en un componente independiente.

Preguntas frecuentes

¿Es la arquitectura componible lo mismo que los microservicios?

No, pero se superponen. Los microservicios son una forma técnica de descomponer un sistema en servicios pequeños y desplegables. La arquitectura componible descompone el sistema según capacidades de negocio, o PBCs, y añade la idea de componentes intercambiables de “mejor de su clase” conectados por APIs.

Los microservicios suelen ser una forma de implementar el backend de un sistema componible. Para una comparación más amplia, consulta monolito versus microservicios.

¿Cuál es la diferencia entre componible y headless?

Headless significa que el front end está separado del back end, de modo que cualquier cliente puede consumir las mismas APIs.

Componible es más amplio: consiste en ensamblar un sistema completo a partir de capacidades independientes conectadas por API. Headless es un principio que los sistemas componibles suelen seguir, pero puedes ser headless en una parte de la pila sin ser completamente componible.

¿Qué es una capacidad de negocio empaquetada?

Una PBC es una unidad autónoma que posee una función de negocio completa, incluyendo datos, lógica, procesos y APIs.

Ejemplos típicos:

  • Pago
  • Búsqueda
  • Inventario
  • Carrito
  • Identidad
  • Catálogo

La clave es que la PBC expone operaciones de negocio, no detalles internos de implementación.

¿Necesito una plataforma de API para ser componible?

Necesitas una forma fiable de diseñar, probar y mantener contratos de API. Puede ser una combinación de herramientas o una plataforma única que cubra diseño, mocking, pruebas y documentación.

Lo importante no es el producto específico, sino la disciplina de contratos. Sin contratos estables, los componentes independientes se convierten en dependencias frágiles.

Conclusión

La arquitectura componible es el concepto general; headless, MACH y microservicios son enfoques relacionados dentro de ese espacio.

El patrón central es simple:

  • capacidades independientes,
  • componentes reemplazables,
  • APIs como tejido conectivo.

La parte crítica es la API. En un sistema componible, el contrato no es un detalle técnico: es el punto donde se integran equipos, proveedores y canales. Si diseñas, simulas, pruebas y documentas bien tus APIs con una herramienta como Apidog, tendrás una base más sólida para construir sistemas intercambiables, multicanal y menos dependientes de un único proveedor.

Top comments (0)