Skip to content

Domain-Driven Design Essentials

Training Format: Live Online / In-Person Duration: 5 Days Download PDF

Request a Corporate Quote

Home›Courses›Domain-Driven Design Essentials

Description

Domain-Driven Design Essentials is designed for technical teams that want to analyze complex business problems correctly, create domain models, and turn those models into sustainable software solutions. In this five-day live online training, the strategic and tactical design components of the Domain-Driven Design approach are covered through real-world scenarios and live coding exercises.

Domain-Driven Design is not just a coding technique. DDD is a problem-solving and software design approach that aims to create a shared language between software teams and business units, break complex business domains into manageable parts, and align software architecture with business requirements.

Participants learn strategic DDD concepts, from the distinction between problem space and solution space to subdomain analysis, from the use of Ubiquitous Language to Bounded Context and Context Mapping. Tactical design components such as Entity, Value Object, Aggregate, Domain Service, Domain Event, Factory, and Repository are then translated into code through hands-on examples.

What Will You Learn in This Training?

  • Explain the Domain-Driven Design approach and its core goals
  • Analyze complex business problems from a domain-focused perspective
  • Identify the difference between problem space and solution space
  • Distinguish between Core, Supporting, and Generic Subdomain structures
  • Establish a shared language between technical and business teams by creating a Ubiquitous Language
  • Define Bounded Context boundaries
  • Model the relationships between different contexts with Context Mapping
  • Use the Event Storming approach for domain discovery
  • Apply the tactical design components of DDD correctly
  • Turn the resulting domain model into working code in C#

 

Who Should Attend?

  • Intermediate and senior software developers
  • Backend developers
  • Software and solution architects
  • Technical leads and team leads
  • Technical teams that work with business analysts on domain modeling
  • Teams building microservices architectures or carrying out application modernization
  • Professionals developing enterprise applications with complex business rules

Outline

1. Introduction to Domain-Driven Design
  • What is Domain-Driven Design?
  • The purpose and core principles of DDD
  • Software development problems addressed by DDD
  • Common misconceptions about DDD
  • Why teams may shy away from DDD: complexity and learning barriers
  • Good, bad, and effective software design
  • The role of DDD in the software development lifecycle
2. Domain and Domain Modeling
  • What is a domain?
  • The relationship between the business problem and the software model
  • Discovering domain knowledge
  • Collaboration between domain experts and software teams
  • The Domain Modeling approach
  • Continuously refining the domain model
  • Maintaining the relationship between the model and the code
3. Problem Space and Solution Space
  • What is the Problem Space?
  • What is the Solution Space?
  • Separating the business problem from the technical solution
  • Understanding business needs correctly
  • Modeling the domain before producing a solution
  • Establishing the relationship between the problem and solution spaces
4. Subdomain Analysis
  • What is a subdomain?
  • Breaking complex domains into subareas
  • Core Domain
  • Supporting Subdomain
  • Generic Subdomain
  • Prioritizing subdomains by business value
  • The relationship between organizational capabilities and subdomains
5. Ubiquitous Language
  • What is Ubiquitous Language?
  • Creating a shared language between business units and technical teams
  • Defining domain concepts clearly and consistently
  • Using the shared language in analysis, documentation, and code
  • Identifying ambiguous and conflicting concepts
  • Evolving the Ubiquitous Language together with the domain model
6. Strategic Domain-Driven Design
  • The purpose of strategic design
  • Decomposing large and complex systems
  • Identifying domain boundaries
  • Relating business capabilities to software boundaries
  • The impact of strategic decisions on software architecture
7. Bounded Context
  • What is a Bounded Context?
  • Defining model boundaries
  • The meanings of the same concept in different contexts
  • The relationship between Bounded Contexts and subdomains
  • Criteria used to define context boundaries
  • Problems caused by incorrect or unclear context boundaries
8. Context Mapping
  • What is a Context Map?
  • Modeling the relationships between Bounded Contexts
  • Evaluating team and system boundaries
  • Sharing data and models across contexts
  • Identifying integration points
  • Carrying Context Mapping results into architectural decisions
9. Event Storming
  • What is the Event Storming approach?
  • Domain discovery and making business processes visible
  • Identifying Domain Events
  • Examining commands, actors, and business rules
  • Business units and technical teams modeling together
  • Using Event Storming outputs in Bounded Context work
10. Tactical Domain-Driven Design
  • The purpose of tactical design
  • Expressing the domain model at the code level
  • Placing business rules in the appropriate layer
  • Rich Domain Model principles
  • Relationships between tactical design building blocks
11. Entities and Value Objects
  • What is an Entity?
  • Identity and lifecycle concepts
  • What is a Value Object?
  • Equality by value
  • Immutability principles
  • Differences between Entities and Value Objects
  • Selecting the appropriate modeling component
12. Aggregates and Aggregate Roots
  • What is an Aggregate?
  • The Aggregate Root
  • Protecting business rules and invariants
  • Defining Aggregate boundaries
  • Managing relationships between Aggregates
  • Avoiding unnecessarily large Aggregate designs
  • Transaction and consistency boundaries
13. Domain Services and Application Services
  • What is a Domain Service?
  • Domain behavior that does not belong to an Entity or Value Object
  • Responsibilities of an Application Service
  • Separating domain and application layers
  • Placing business rules correctly within services
14. Domain Events
  • What is a Domain Event?
  • Modeling significant changes within the domain
  • Creating and publishing Domain Events
  • Reducing dependencies between components
  • Connecting Domain Events with business processes
15. Factories, Repositories and Modules
  • The purpose of the Factory approach
  • Managing complex object creation
  • What is a Repository?
  • Separating the domain model from the data access mechanism
  • Defining Repository boundaries
  • Using Modules and organizing the model
16. DDD and Clean Architecture
  • The Clean Architecture approach
  • The position of the domain layer within the architecture
  • Directing dependencies toward the inner layers
  • Separating domain, application, and infrastructure responsibilities
  • Developing a technology-independent domain model
  • Testable and maintainable software design
17. Coding Workshop
  • Discovering the domain through a real-world problem
  • Analyzing the Problem Space and Solution Space
  • Identifying subdomains and the Core Domain
  • Creating a Ubiquitous Language
  • Modeling Bounded Context boundaries
  • Applying strategic and tactical DDD concepts
  • Translating the domain model into C# code
  • Implementing Entity, Value Object, and Aggregate designs
  • Developing Repository and Domain Service components
  • Live coding and solution review exercise

Prerequisites

  • Participants are expected to have at least intermediate-level programming knowledge.
  • Knowing a widely used object-oriented programming language is sufficient.
  • Because the hands-on exercises are carried out in C#, basic C# knowledge is recommended.
  • Participants’ computers must have Visual Studio or Rider, Docker, and C# 8.0 (or the compatible version announced for the training) installed.

What Does Domain-Driven Design Provide?

Domain-Driven Design focuses on the business problem that must be solved before the technical components of the software. Modeling business concepts correctly enables clearer communication among software developers, domain experts, and business units.

DDD creates particular value in projects with complex business rules, multiple subdomains, and enterprise applications that will be developed over a long period. That said, not every project needs to use every DDD component. The scope of the approach should be determined by the complexity of the business domain and the actual needs of the project.

The Relationship Between DDD and Microservices Architecture

Domain-Driven Design and microservices architecture are not the same concept. DDD focuses on modeling the business domain and defining the right software boundaries. Microservices, on the other hand, is an architectural approach that allows applications to be designed as services that can be developed and deployed independently.

The subdomain and Bounded Context work used in DDD can help define microservice boundaries. However, not every Bounded Context needs to automatically become a separate microservice. When defining service boundaries, team structure, data ownership, integration, and operational requirements should be evaluated along with the business model.

To learn more about microservices design and distributed systems, you can review the Microservices Training Courses page.

Customized Domain-Driven Design Training for Your Organization

The training can be customized by taking into account the organization’s industry, software architecture, technology stack, the experience level of the teams, and the domain modeling problems they face. Using business scenarios close to the organization in the workshops makes it easier to carry DDD concepts over into real projects.

Teams working with C# and Microsoft technologies can review the Corporate .NET Training Courses, and teams developing Java-based projects can review the Corporate Java Training Courses programs.

To improve object-oriented design patterns, you can review the Java Design Patterns Training, and for a test-driven development approach, the Test Driven Development (TDD) Training. For broader enterprise architecture approaches, you can visit the Enterprise Architecture Training Courses page.

To get information about content, planning, and a quote for BlueMark Academy’s corporate Domain-Driven Design Training, you can fill out the contact form.

Frequently Asked Questions

What is Domain-Driven Design?

Domain-Driven Design is a software development approach that focuses on modeling complex business problems based on domain knowledge and aligning software design with that model.

Who is the Domain-Driven Design Training for?

The training is suitable for intermediate and senior software developers, backend developers, software and solution architects, technical leads, and teams working on microservices or application modernization projects.

What is the difference between strategic and tactical DDD?

Strategic DDD focuses on concepts that define system boundaries, such as subdomains, Bounded Context, Ubiquitous Language, and Context Mapping. Tactical DDD covers the components that express the domain model in code, such as Entity, Value Object, Aggregate, Domain Service, and Repository.

What is a Bounded Context?

A Bounded Context is an explicit boundary within which a particular domain model and the concepts used in that model are valid. The same term can have different meanings in different Bounded Contexts.

What is Event Storming?

Event Storming is a collaborative modeling approach used to discover and make visible the important events, commands, actors, and business rules in a business domain through teamwork.

Is DDD used only in microservices projects?

No. Domain-Driven Design can be used in both monolithic and distributed systems. DDD can help define microservice boundaries, but it is not specific to microservices projects.

How many days does the Domain-Driven Design Training last?

The training lasts five days and is delivered live online or in person.

Which programming language is used in the training?

The hands-on exercises are carried out in C#. Participants are recommended to have intermediate programming knowledge and basic C# experience.