Architecture that Speaks the Business Domain!

The success of a software system is only as great as its ability to support users in accomplishing defined tasks.
Domain-Driven Design (DDD) increases this likelihood of success by structuring software from the very beginning based on the business domain.
Domain experts and technical teams collaborate to develop a clear and consistent domain language that is applied across all levels,
including the source code. This approach not only helps to prevent communication issues and their potential consequences early on
but also enables qualitative improvements, such as avoiding anonymous setters and helpers.
Predefined patterns such as Entity, Value Object, Aggregate, and Service simplify communication within the development team
and lead to a unified, high-quality architecture.

What can you expect?

Domain language and patterns not only work for a single system but also in large software projects with multiple development teams or in separately developed (micro-) services.
Here, concepts such as Bounded Context, Context Map, Shared Kernel, Domain Events, Anticorruption Layer, etc. come into play.
In this iSAQB-certified software architecture training, you will learn why complex software projects can be conducted more transparently for all parties through Domain-Driven Design (DDD).
At the same time, you will gain hands-on experience with a range of techniques and elements that can help achieve an optimized domain model.
Core topics include Event Storming to understand the domain, strategic thinking to divide the domain, and cutting and distinguishing models from each other.
Other topics include Ubiquitous Language, Domain-Logic patterns, and Tactical Design. Advanced topics such as Local Model Consistency, implementation of Building Blocks, Design by Contract, CQRS, Event Sourcing, and Microservices are also covered.

Prerequisites for Participants

➤ You should have a good grasp of the basics and advanced concepts of object-oriented software development.
➤ Experience in modeling object-oriented architectures is required.
➤ Knowledge of agile methods such as Scrum, Kanban, or XP is helpful.
➤ You should have prior experience in collaboration between business departments and software developers.
➤ A basic understanding of domain models and their practical application will make it easier for you to get started.

Technical Requirements

There are no specific requirements for the training environment, as the exercises are conducted using cloud-based and web-based tools such as Miro, Draw.io, and platforms like Jupyter or HuggingFace.
All that is required is a stable and sufficiently fast internet connection.

Your Added Value

➤ You will learn how to develop complex domain models that accurately represent the business domain.
➤ You will gain the skills to establish a common language between business and IT experts.
➤ You will be able to design models iteratively and agilely, organizing effective collaboration with domain experts.
➤ You will understand how domain models can be integrated into software architectures and strategically cut.
➤ You will deepen your knowledge in techniques such as Event Storming, Context Mapping, and Modularization.
➤ You will be able to tackle the challenges of large, distributed systems and create sustainable software solutions.

Training Content in Detail

✔️ Domain, Model, and Ubiquitous Language
➤ Capture domain knowledge in a structured way and map it into a model
➤ Establish a unified language for developers and domain experts
✔️ The Path to the Model
➤ Use modeling techniques like Event Storming or Domain Storytelling
➤ Extract knowledge from domain experts and refine it iteratively
✔️ From Model to Implementation
➤ Connect domain models with technical building blocks such as Aggregates, Repositories, and Services
➤ Understand the impact of model changes on the implementation
✔️ The Model in Application Architecture
➤ Integration into architectural concepts like Hexagonal Architecture or Layered Architecture
➤ Clarify the connection between Domain-Driven Design and Behavior-Driven Development
✔️ Cutting and Distinguishing the Model
➤ Define Bounded Contexts and create clear interfaces between models
➤ Identify subdomains and strategically divide them into Core, Supporting, and Generic Subdomains
✔️ Maintain Local Model Consistency
➤ Use Anti-Corruption Layers to isolate external dependencies
➤ Use Domain Events as an asynchronous communication tool between Bounded Contexts

Your Benefits at a Glance

➤ Clear Business Language & Better Communication: A unified Ubiquitous Language facilitates collaboration between developers and domain experts.
➤ Structured Modeling & Scalability: With Bounded Contexts and strategic model division, software remains manageable even with increasing complexity.
➤ Flexibility & Adaptability: Domain models can be iteratively developed to adapt to new requirements.