Domain Driven Design (DDD)

Domain Driven Design (DDD) is a software design methodology introduced by Eric Evans in 2003. This approach prioritizes deep modeling of the business domain and encourages continuous collaboration between developers and domain experts to create a common language and shared models. DDD transforms business complexity into maintainable and scalable software architecture.

Fundamentals of Domain Driven Design

• Ubiquitous Language: a shared language between developers and domain experts that reflects directly in the code
• Bounded Context: clear delimitation of each subdomain's boundaries with its own models and rules
• Strategic Design: global architectural vision organizing relationships between contexts and identifying the Core Domain
• Tactical Patterns: design patterns (Entities, Value Objects, Aggregates, Repositories) structuring business code

Benefits of DDD

• Business-technical alignment: reduces the gap between business needs and technical implementation
• Enhanced maintainability: expressive code faithfully reflecting business processes and facilitating evolution
• Complexity management: decomposition into bounded contexts enabling mastery of sophisticated business domains
• Reusability: well-defined business models adaptable to different contexts
• Improved communication: ubiquitous language eliminating ambiguities and misunderstandings between teams

Practical Example: Booking System

// Bounded Context: Booking

// Value Object
class BookingPeriod {
  constructor(
    public readonly startDate: Date,
    public readonly endDate: Date
  ) {
    if (startDate >= endDate) {
      throw new Error('End date must be after start date');
    }
  }

  overlaps(other: BookingPeriod): boolean {
    return this.startDate < other.endDate && other.startDate < this.endDate;
  }
}

// Entity (Aggregate Root)
class Booking {
  private status: 'pending' | 'confirmed' | 'cancelled';
  
  constructor(
    public readonly id: BookingId,
    public readonly resourceId: ResourceId,
    private period: BookingPeriod,
    public readonly customerId: CustomerId
  ) {
    this.status = 'pending';
  }

  // Business method using Ubiquitous Language
  confirm(): void {
    if (this.status !== 'pending') {
      throw new Error('Only pending bookings can be confirmed');
    }
    this.status = 'confirmed';
    // Emit domain event: BookingConfirmed
  }

  cancel(reason: CancellationReason): void {
    if (this.status === 'cancelled') {
      throw new Error('Booking is already cancelled');
    }
    this.status = 'cancelled';
    // Emit domain event: BookingCancelled
  }
}

// Repository Interface
interface BookingRepository {
  save(booking: Booking): Promise<void>;
  findById(id: BookingId): Promise<Booking | null>;
  findOverlapping(resourceId: ResourceId, period: BookingPeriod): Promise<Booking[]>;
}

Implementing DDD

1. Event Storming: collaborative workshops to identify business events, commands, and aggregates
2. Define ubiquitous language: create and actively maintain a shared business glossary
3. Identify Bounded Contexts: map subdomains and their boundaries
4. Tactical modeling: implement patterns (Entities, Value Objects, Aggregates, Domain Services)
5. Hexagonal architecture: isolate domain from technical concerns (infrastructure, API)
6. Business-oriented testing: validate business rules through expressive and readable tests
7. Continuous iteration: refine the model through discoveries and business evolution

DDD Tools and Frameworks

• NestJS with CQRS: Node.js framework offering abstractions for Event Sourcing and CQRS
• Axon Framework: Java platform facilitating DDD and Event Sourcing implementation
• EventStorming: collaborative methodology to discover and model the domain
• Context Mapper: visual modeling tool for Bounded Contexts and their relationships
• Domain Storytelling: narrative technique to capture business processes

Domain Driven Design represents much more than a set of technical patterns: it's a philosophy placing deep business understanding at the center of the development process. By adopting DDD, organizations significantly reduce maintenance costs, accelerate time-to-market for new features, and create systems truly aligned with their strategic objectives. This approach is particularly relevant for complex business domains where collaboration between business and technical experts becomes a decisive competitive advantage.