JAFSJosé Antonio Fuentes Santiago

DDD en un apocalipsis zombi. Preguntas frecuentes

02-04-2026

En las entregas anteriores comenzamos construyendo el vocabulario del refugio usando el lenguaje ubicuo y terminamos con patrones más avanzados como patrón Outbox. Ha sido un viaje intenso, pero antes de cerrar la puerta del refugio, toca responder a esas dudas que siempre surgen cuando intentas aplicar esto en un proyecto real. Además, veremos una checklist y una pequeña guía que os ayudará a decidir cuándo tiene sentido aplicar DDD y cuándo no.

¿Cómo sé si algo es un Value Object o una Entidad?

Si tienes dudas, usaremos el test de intercambio. Hazte esta pregunta: ¿Puedo cambiar este objeto por otro igual sin que pase nada?

  • Value Object: Solo importan sus atributos. Si tienes una lata de atún, te da igual qué lata sea mientras sea de atún y pese 100g. Si la cambias por otra idéntica, el sistema no nota la diferencia. Importa qué es.
  • Entidad: Tiene un historial y una identidad. No puedes cambiar a Ana por Borja aunque tengan la misma edad. Ana tiene su pasado, sus relaciones y su puesto en la guardia. Importa cuál es.

Es decir, si el objeto tiene un ID que lo identifica a lo largo del tiempo, es una Entidad. Si solo es un puñado de datos, es un Value Object.

Algunos ejemplos:

  • Un walkie-talkie: depende. Si solo necesitas saber "tenemos 3 walkies operativos", es un VO. Si asignas cada walkie a una persona con número de serie y historial de averías, es una Entidad.
  • Una ración de comida: será un value object casi siempre. A nadie le importa qué te comas una lata de atún de 100g u otra igual, solo cuántas hay.
  • Una misión de exploración: será una entidad. Tiene estado que evoluciona, responsables asignados, cosas que le ocurren a esa misión en particular.

¿Cuándo pongo lógica en el agregado y cuándo en un Servicio de Dominio?

Para salir de dudas puedes mirar la tablilla siguiente:

Caso Dónde va
Lógica que cambia el estado de un agregado Método en ese agregado
Lógica que involucra varios agregados Servicio de Dominio
Cálculo o regla sin estado que no pertenece a nadie Servicio de Dominio

No uses los servicios para "vaciar" tus agregados (mal símil 😛). Si el servicio hace todo el trabajo y el agregado solo tiene getters y setters, tienes un modelo anémico. El servicio debe orquestar, pero la lógica de verdad (las reglas de negocio) debe estar protegida dentro de tus clases de dominio.

¿Necesito implementar siempre todos los conceptos de DDD?

No. DDD es una caja de herramientas de la que puedes extraer sólo lo que necesites. Puedes tener Entidades y Value Objects sin necesitar Sagas. Puedes aplicar el lenguaje ubicuo sin implementar Eventos de Dominio. Puedes tener Repositorios sin dividir en Bounded Contexts.

Empieza por el lenguaje ubicuo y los agregados con invariantes. Añade el resto cuando el problema lo requiera. La complejidad extra solo vale la pena cuando resuelve un problema real que ya tienes, no uno que podrías tener algún día.

¿Cómo sé si mi agregado es demasiado grande?

Un error típico es querer meter todo en el mismo sitio. Para saber si debes dividir un agregado, fíjate en las invariantes (recuerda, las reglas que no se pueden romper).

Si para que una regla de negocio se cumpla necesitas que el dato A y el dato B se guarden sí o sí en la misma transacción, van en el mismo agregado.

  • Ejemplo: No puedes añadir un superviviente si el refugio está lleno. Como el "contador" y el "listado" deben ir de la mano, van juntos.
  • Contrajemplo: El historial médico de un superviviente y los suministros de comida. Si uno cambia, al otro le da igual. Sepáralos.

Si tu agregado tiene colecciones que raramente se modifican juntas, o donde un cambio en una parte nunca afecta a las reglas de otra, es una señal de que puede dividirse.

¿Cómo integro modelos de diferentes contextos sin acoplarlos?

Cuando Logística necesita saber algo que solo conoce Sanidad, la tentación es compartir la clase. No lo hagas, ya que eso destruirá el aislamiento que tanto te costó construir.

Es por ello que debes utilizar las herramientas adecuadas para comunicarse sin acoplarse:

  • Eventos de dominio: Sanidad emite BroteDetectado con solo la información que otros contextos necesitan (refugio afectado, personas en riesgo). Sin objetos médicos internos.
  • DTOs: objetos simples sin comportamiento que representan exactamente lo que el contexto productor quiere exponer.
  • Anti-corruption layer (ACL): un adaptador en el contexto consumidor que traduce lo que recibe al modelo local. Si Logística recibe eventos de Sanidad, el ACL los convierte a conceptos logísticos sin que el modelo logístico sepa nada de historiales médicos.

Cuando el contexto consumidor tiene que entender la estructura interna del contexto productor es una clara señal para que pases a usar un ACL.

¿Cómo sé que el diseño de mi dominio es correcto?

En este caso puedes plantearte lo siguiente: si para verificar una regla de negocio del dominio necesitas levantar una base de datos o configurar mocks de infraestructura, algo va mal. El dominio puro no debe necesitar nada externo para que sus reglas sean verificables.

Si por ejemplo, el test de "el refugio lleno rechaza nuevos supervivientes" requiere un repositorio real eso es porque la lógica de negocio la has llevado fuera del dominio.

¿Puedo usar diferentes bases de datos en un mismo contexto?

¡Claro!. El criterio para delimitar un Bounded Context es el dominio, no la tecnología de persistencia.

El contexto (Bounded Context) se define por el lenguaje y el negocio, no por la tecnología. Si para gestionar supervivientes usas PostgreSQL para los datos y Elasticsearch para las búsquedas, ambos repositorios viven en el mismo contexto porque hablan de lo mismo.

Es por ello que las interfaces de los repositorios se ubican en el dominio:

// Dominio - define QUÉ necesita, sin saber CÓMO
interface SurvivorRepository {
  save(survivor: Survivor): Promise<void>;
}

interface SurvivorSearchRepository {
  searchBySymptoms(symptoms: string[]): Promise<Survivor[]>;
}

Y en infraestructura tienes dos implementaciones distintas, cada una con su tecnología:

// Implementa el guardado
class PostgresSurvivorRepository implements SurvivorRepository { ... }

// Implementa la búsqueda por síntomas
class ElasticSurvivorSearchRepository implements SurvivorSearchRepository { ... }

Ambas interfaces viven en el mismo contexto porque sirven al mismo modelo de dominio. La capa de aplicación las usa de forma independiente según qué necesite cada caso de uso.

La señal de que algo debe ir a otro contexto no es que use "una tecnología diferente", sino el que "hable de conceptos distintos o tenga un modelo que diverge del resto".

¿Cómo sé que el sistema está funcionando antes de que llegue la horda?

Un sistema con Sagas y procesos largos puede fallar de formas muy poco visibles: una transferencia que nunca termina, una compensación que no se ejecuta o un evento que se publica pero nadie procesa. Si no tenemos todo bajo control, estos fallos aparecen demasiado tarde, y normalmente cuando hay zombis atravesando el perímetro.

La observabilidad es justo eso: saber qué está pasando dentro del sistema antes de que todo se descontrole.

Por un lado tenemos las trazas distribuidas: para poder seguir todo el flujo en caso de error, utiliza lo que se llama correlationId, que es como el número de expediente de cada proceso. Si lo vas propagando por todos los comandos y eventos, luego puedes reconstruir el recorrido completo y ver dónde se paró.

En tu panel de control del refugio deberías vigilar estas métricas:

  • Cuánto tarda cada Saga en completarse.
  • Cuántas acaban en compensación.
  • Cuántos eventos siguen esperando en el outbox.
  • Qué tipos de error se repiten más.

Además, puedes establecer alarmas en los casos de que una Saga se queda atascada, si la tasa de compensación sube o si la cola de outbox no deja de crecer. Esos casos indican que algo va mal y conviene mirarlo cuanto antes.

PARA SABER MÁS

El tema de la observabilidad da para mucho. Si quieres profundizar en él, Observability Engineering de Charity Majors, Liz Fong-Jones y George Miranda es la referencia más completa sobre el tema.

Checklist rápido de DDD

Antes de dar por buena tu implementación, deberías revisar estos puntos:

Lenguaje y comunicación

  • ¿Hay un glosario de términos del dominio compartido por todo el equipo?
  • ¿Los nombres en el código coinciden exactamente con los que usan los expertos del negocio?
  • ¿Puedes explicar el código a alguien del negocio sin traducir mentalmente?

Agregados y reglas de negocio

  • ¿Los agregados tienen métodos con lógica de negocio, no solo getters/setters?
  • ¿Las invariantes están protegidas en la raíz del agregado?
  • ¿Es imposible romper las reglas del negocio desde fuera del agregado?

Persistencia y separación de capas

  • ¿Los repositorios son interfaces en el dominio, implementadas en infraestructura?
  • ¿El dominio no sabe nada de SQL, MongoDB o cualquier tecnología de persistencia?
  • ¿Los agregados exponen toSnapshot() y reconstitute() en lugar de getters individuales?
  • ¿Puedes cambiar de base de datos sin tocar el dominio?

Eventos y consistencia

  • ¿Los eventos se guardan en el outbox dentro de la misma transacción que el estado del agregado?
  • ¿Los consumidores de eventos son idempotentes?
  • ¿Los handlers de comandos son idempotentes (usan commandId para detectar duplicados)?
  • ¿Las transferencias entre agregados usan consistencia eventual en lugar de transacciones que cruzan fronteras?
  • ¿Los estados intermedios inválidos (como el superviviente nómada) están modelados como conceptos de dominio explícitos?
  • ¿Las Sagas en curso tienen su estado persistido para sobrevivir a reinicios del servidor?
  • ¿Tienes trazas y métricas para detectar Sagas atascadas o con tasa de compensación anómala?

Bounded Contexts

  • ¿Cada contexto tiene su propio modelo y lenguaje?
  • ¿Hay contratos claros entre contextos (eventos, DTOs, APIs)?
  • ¿Un cambio en un contexto no rompe automáticamente otros contextos?
  • ¿Tienes tests de contrato para asegurar que los eventos y DTOs no rompen a los consumidores?

Tests

  • ¿Los tests verifican invariantes del dominio, no detalles de implementación?
  • ¿Puedes testear el dominio sin levantar una base de datos?
  • ¿Cada regla de negocio importante tiene al menos un test?
  • ¿Los tests de Sagas verifican que cada evento produce el comando correcto?
  • ¿Los tests de Sagas verifican que ante un fallo se emite la compensación adecuada?

Si respondiste "no" a varios de estos puntos, puede ser porque no necesites todas las herramientas de DDD. Pero cuidado si has respondido no a prácticamente todos, porque seguro que ya habrá un zombi a tu espalda mientras piensas que estás haciendo DDD.

¿Cuándo usar DDD? (y cuándo NO)

No todo sistema necesita el nivel de ingeniería de un refugio de alta seguridad. Un puesto de observación temporal, un almacén de paso, una guarida de una sola noche: cada escenario tiene sus propias necesidades y sus propios costes. Aplicar la misma arquitectura a un CRUD sencillo que a un sistema de evacuaciones coordinadas es tan contraproducente como instalar un sistema de exclusas de descontaminación en una cabaña en un árbol: te costará, perderás el tiempo y encima quizás se caiga en cuanto sople viento.

DDD no es la panacea para todos los problemas. Es una herramienta poderosa, pero recuerda: "todo gran poder conlleva una gran responsabilidad".

De todas formas, no hace falta aplicar DDD al 100% desde el primer día. Puedes identificar las partes más complejas del dominio y aplicarlo ahí, dejando el resto. Con el paso del tiempo, podrás evolucionar gradualmente el sistema a medida que éste crece y los problemas aparecen.

Recuerda que DDD es una filosofía, no una religión. Así que toma lo que te sirva y aplícalo donde tenga sentido.

Usa DDD cuando...

  • El dominio es complejo y cambiante: reglas de negocio interdependientes que evolucionan con frecuencia. Un sistema de gestión de seguros con cientos de casos especiales, una plataforma de trading financiero con reglas de riesgo complejas, o nuestro apocalipsis zombi con refugios, infecciones y evacuaciones coordinadas.
  • Hay reglas de negocio valiosas que proteger: si tu aplicación tiene lógica que no puede romperse bajo ninguna circunstancia, DDD te da los mecanismos para garantizarlo.
  • Trabajas cerca de gente experta del dominio: DDD funciona mejor cuando puedes tener conversaciones directas con quienes entienden el negocio y esas conversaciones alimentan directamente el código. Si no puedes hablar con las personas expertas, desarrollar un lenguaje ubicuo es prácticamente imposible.
  • El proyecto es a largo plazo: DDD tiene una curva de aprendizaje que hará que al principio vayas más despacio. Pero si el proyecto va a vivir muchos meses, o incluso años, la inversión vale la pena: el código es más mantenible, las nuevas funcionalidades encajan con más naturalidad y el conocimiento del dominio no desaparece cuando alguien se va del equipo.

NO uses DDD cuando...

  • El dominio es trivial: si tu aplicación es un formulario conectado a una base de datos sin reglas complejas, DDD es overkill. Quizás un CRUD bien hecho con Active Record (aunque se considere un anti-patrón) sea la solución correcta, y no hay nada de malo en eso.
  • No tienes acceso a expertos del dominio: sin colaboración con quienes entienden el negocio, no puedes modelar correctamente ni desarrollar un lenguaje común. DDD sin esa colaboración puedes comenzar a añadir suposiciones al lenguage ubicuo e introducir reglas de negocio erróneas.
  • Desarrolles un prototipo o un MVP de vida corta: si necesitas validar una idea rápido y no sabes si el proyecto sobrevivirá, no inviertas en DDD. Haz el CRUD rápido, valida la hipótesis, y si el proyecto crece ya habrá tiempo de refactorizar hacia un modelo más rico. Más ahora con la ayuda de la IA, que podrás refactorizar en poco tiempo.
  • El equipo no está listo: DDD requiere entender bien OOP, encapsulación e inversión de dependencias. Intentar aplicarlo con un equipo que aún está aprendiendo esos fundamentos es una receta para el caos.

El refugio cierra sus puertas (por ahora)

Con esta entrega cerramos la serie de DDD en un apocalipsis zombi. Cinco artículos después, hemos recorrido un largo camino. Si has llegado hasta aquí, lo primero de todo, muchas gracias. Ya tienes las herramientas para que tu código hable el idioma del dominio y sobreviva a la producción sin propagar el virus Z.

Eso sí, hay temas que no he podido añadir a los artículos, ya sea por extensión o por complejidad. Esos temas que quedaron fuera merecen también su espacio propio.

Por eso estoy escribiendo Guía de Domain-Driven Design en un Apocalipsis Zombi, un libro que surge como una historia alternativa a Guía de programación en un Apocalipsis Zombi y que ampliará todo lo que hemos visto aquí. Técnicamente cubrirá los temas vistos y todo lo que quedó fuera.

Si la serie te ha resultado útil, el libro va a llevarlo bastante más lejos.

Recordad, ¡mantened las puertas cerradas y el código limpio!

Otros artículos de la serie

  • Parte 1: Lenguaje ubicuo, bounded contexts, entidades, objetos de valor y agregados.
  • Parte 2: Servicios de dominio, repositorios, capa de aplicación y eventos de dominio.
  • Parte 3: Sagas, antipatrones y pruebas.
  • Parte 4: Patrón Outbox, consistencia eventual entre agregados, el patrón Snapshot.
ESTO SIGUE EN EL REFUGIO

Si te has quedado con ganas de más arquitectura, en Domain-Driven Design en un Apocalipsis Zombi lo cuento entero: entidades, agregados, contextos delimitados y un refugio que aguanta cuando el proyecto crece. En tapa blanda y Kindle, y gratis si tienes Kindle Unlimited.

Si quieres seguir por donde lo deja este artículo, en el libro tienes:

  • Capítulo 11, «Sagas»: el apartado «Sagas atascadas», con los timeouts, el límite de reintentos y qué contexto guardar.
  • Capítulo 14, «Event Storming»: el taller fase a fase, de la pared al código.
  • Apéndice A, «¿Cuándo usar DDD? (y cuándo no)».
  • Apéndice B, «DDD en otros dominios»: una tienda online, una plataforma de streaming y una farmacéutica.
  • Apéndice C, «Preguntas frecuentes»: más preguntas como las de este artículo.