Many organisations invest in collaborative modelling practices such as EventStorming and Example Mapping to improve communication between business and technology. These sessions often create valuable insights and a strong shared understanding of the domain. Yet when implementation starts, teams frequently struggle to preserve that understanding in the code itself.

Business concepts become diluted by technical abstractions. Domain logic leaks into infrastructure layers. Responsibilities are distributed inconsistently across services and classes. Over time, the software no longer reflects the ubiquitous language that teams originally established together.

Model-Driven Design: From Collaborative Modelling to Code focuses on maintaining alignment between domain understanding and software implementation. Participants learn how to move deliberately from collaborative exploration toward production-ready code using Domain-Driven Design tactical patterns and responsibility-driven design techniques.

The training combines collaborative modelling with intensive implementation practice. Participants translate EventStorming and Example Mapping outcomes into object-oriented domain models, use CRC cards to allocate behaviour across the model, and apply outside-in Test-Driven Development to implement domain behaviour in Java or C#. The workshop covers entities, value objects, aggregates, domain events and hexagonal architecture principles, always with a focus on preserving business intent inside the codebase.

Approximately 70% of the workshop is hands-on. Day one focuses on collaborative discovery and modelling. Day two is heavily implementation-oriented and includes multiple coding labs where participants apply DDD tactical patterns in realistic scenarios.

The training is especially valuable for software developers, tech leads and architects who want to strengthen the connection between collaborative modelling, software design and maintainable implementation practices. It also addresses how these skills remain highly relevant in a world of AI-assisted software development, where clear domain models and explicit design decisions become even more important for generating reliable and maintainable systems.

Program

This is a two-day instructor-led workshop combining collaborative modelling techniques with intensive coding practice in Java or C#.

Day 1: Understanding the Problem Space Through Collaborative Modelling

Participants explore the foundations of Domain-Driven Design and the challenge of maintaining alignment between models and implementation. Through EventStorming and Context Mapping, they collaboratively explore business processes, identify bounded contexts and establish a ubiquitous language that guides implementation decisions. The day focuses on making implicit domain knowledge explicit and creating clear boundaries for software design.

Day 2: From Domain Model to Production Code

The second day focuses on implementation. Participants use Example Mapping to clarify business rules and apply responsibility-driven design using CRC cards to shape their domain model. Through multiple coding labs, they implement entities, value objects, aggregates and domain events using outside-in Test-Driven Development. The workshop also introduces hexagonal architecture principles to protect domain logic from infrastructure concerns and explores how to maintain model-code alignment as systems evolve.

The format provides extensive room for discussion, peer learning and hands-on experimentation with realistic implementation scenarios.

After This Training

After completing this training, participants are able to:

• Translate collaborative modelling outcomes into object-oriented domain models
• Apply Domain-Driven Design tactical patterns in Java or C#
• Use CRC cards and responsibility-driven design techniques effectively
• Implement domain behaviour using outside-in Test-Driven Development
• Distinguish between entities, value objects, aggregates and domain events
• Protect domain logic using hexagonal architecture principles
• Maintain alignment between ubiquitous language, models and implementation
• Refactor and evolve domain models as understanding grows
• Write maintainable, testable software that reflects business intent more clearly
• Provide clearer domain context for both human developers and AI-assisted development tools

Together We Continue Building

At Connected Movement, learning is closely connected to practice. During and after the workshop, participants continue exchanging experiences, implementation challenges and lessons learned with peers and practitioners from the Connected Community.

Together with experienced Domain-Driven Design practitioners, we help organisations strengthen the connection between collaborative modelling, software architecture and maintainable implementation practices in complex environments.

Certification

Upon completion of the workshop, participants receive a certificate of participation recognising their engagement with model-driven design principles, collaborative modelling techniques and Domain-Driven Design tactical pattern implementation.