Domain Driven Design Microservices for Architects

Learn how to build Microservices applications starting with business analysis and domain driven design
Domain Driven Design Microservices for Architects
File Size :
2.74 GB
Total length :
12h 41m



Rajeev Sakhuja


Last update




Domain Driven Design Microservices for Architects

What you’ll learn

Domain Driven Design
Architecting Microservices Application
Design Patterns for building Microservices & Distributed systems
Event Driven Architecture
Developing API for Microservices
Event Storming
Develop a Business case for Microservices

Domain Driven Design Microservices for Architects


Understanding of software development practices
Basic knowledge JAVA or any other programming language


PS: Focus is on designing Microservices not coding No specific Microservices framework in useAll sample code is in plain JAVA to demonstrate/clarify understanding of DDD patterns, etc.Models are developed in UML – using the PlantUML toolPostgreSQL/MongDB/RabbitMQ/Kafka – free instances created on the cloud for demos & walkthroughsPLEASE Do NOT join the course if you are looking for tutorials on Microservices Coding or specific framework!!!What is this course about?Microservices is a new way of building software in which an application is composed of an independent set of services. The biggest benefit of Microservices is that it enables an organization to transform at a very rapid pace. This speed to market is achieved due to the independent nature of the services that make up a Microservices application. Companies like Amazon, Netflix and Etsy have proven the value of Microservices beyond doubt.Many organizations today are looking to adopt Microservices. These organizations are investing in technologies, tools, skills and are changing their software development and delivery processes as well. But still many organizations are failing to achieve the full benefits of Microservices; in fact many organizations feel that they have created technical debt by adopting Microservices. So why is it that some organizations have been successful in adopting Microservices while others are not. One common aspect I have observed in companies that fail to adopt Microservices is that they treat Microservices as a purely technology initiative. They do not spend time in understanding the business aspects of their Microservices applications  !!!Microservices is NOT just about technologyThe key element of the Microservices architecture is that services are Independent. This independent aspect of the service is what makes it possible for Microservices to change independently of other services. If scope of the microservices is leading to inter-dependencies between services then it would lead to a need for change coordination between teams which in turn will lead to the same problems we have with Monolithic applications !!! Release cycles will be longer and there will be no benefit of the adoption of Microservices. To ensure that these is no interdependencies between Microservices, a Microservices architect needs to understand the domain and then decide on the boundary and scope of the Microservices. This is where Domain Driven Design comes into picture. Once the Microservices business boundaries are defined the services should be built using appropriate Microservices design patterns and technologies.Teams working on Microservices should not just look at the technical aspects of the service but MUST keep in mind that there are other considerations that play a critical part in the success of Microservices initiative. In order toRole of a Microservices ArchitectAn IT professional working in the role of Microservices architect is responsible for may aspects depending on the maturity of Microservices adoption in their organization. Here are the list of activities that the architects is responsible for:Evaluate the business benefits of Microservices for their specific organizationBuild a Business case for MicroservicesEducate the Business & IT stakeholders on pros/cons of MicroservicesApply Domain Driven Design to demarcate the boundaries of MicroservicesDefine the domain model for the MicroservicesDo the technical design of MicroservicesGuide and Mentor the Microservices teamsEvaluate the technologies | frameworks for the realization of MicroservicesBuild proof of concepts to show how things workHow will this course help?This course will help developers & architects in building skills needed for successful implementation of Microservices applications. It consists of a combination of concepts, UML modelling and working code to demonstrate the implementation of Microservices. Students will learn the concepts of Domain driven design by way of common industry examples and a case study (ACME travels).  Focus is on Architecture, Design and Development of Microservices. 1. Transformation & Microservices2. Domain Driven Design3. Applying the DDD strategic & tactical pattern4. Event Driven Architecture5. Event Storming6. Data Management7. Messaging8. Distributed Transactions9. APIIMPORTANT: Code SamplesFocus is on the Microservices design not coding.All of the sample code is in plain JAVACourse does NOT cover any specific frameworkSpringBoot is used in samples for API/GraphQL sectionPlease check out the course preview lectures before enrolling the course.Review the topics coveredMake sure you understand instructor’s accentPre-RequisitesBasic understanding of JAVA or any other programming languageSome experience with software development practicesPS:Hand on part is optional but students are encouraged to do hands on tasks to get a better feel of the design patterns.


Section 1: Course Ouline

Lecture 1 Author introductions and Course outline

Lecture 2 Development tools and setup

Section 2: Microservices Architecture

Lecture 3 Microservices Architecture

Lecture 4 Business & Digital Transformation

Lecture 5 A Business Perspective of Microservices

Lecture 6 A Technical Perspective of Microservices

Lecture 7 Adoption of Microservices Architecture

Section 3: Introduction to Domain Driven Design

Lecture 8 Domain, Sub-Domain and Domain Experts

Lecture 9 Conceptual models, Architecture and Design

Lecture 10 Modeling techniques & Architectural Styles

Lecture 11 Domain Models

Lecture 12 Modeling techniques & Architectural Styles

Section 4: Understanding the Business Domain

Lecture 13 Why understand the Business?

Lecture 14 Introduction to Business Model Canvas

Lecture 15 Exercise : ACME Travels Business Model Canvas

Section 5: Domain Driven Design : Strategic Patterns

Lecture 16 Introduction to DDD and Patterns

Lecture 17 Business Subdomain Types

Lecture 18 Exercise : ACME Subdomain Type Assignment

Lecture 19 Understanding the Business Context

Lecture 20 Business Domain Language

Lecture 21 Strategic Pattern : Ubiquitous Language

Lecture 22 Exercise : Define ACME’s Ubiquitous Language

Lecture 23 Strategic Pattern : Bounded Context

Lecture 24 Discovering the Bounded Contexts in a Domain

Lecture 25 Exercise : Identify ACME’s Bounded Contexts

Section 6: Bounded Context Relationships

Lecture 26 Intro to DDD Integration Patterns

Lecture 27 Managing BC Relationships using Context Maps

Lecture 28 Symmetric Relationship Patterns

Lecture 29 Asymmetric Relationship Patterns

Lecture 30 One to Many Relationship Patterns

Lecture 31 Exercise : Context Mapping for a Bank

Section 7: Domain Driven Design – Tactical Patterns

Lecture 32 Intro to DDD Tactical Patterns

Lecture 33 Entity Object – Pattern

Lecture 34 Value Object – Pattern

Lecture 35 Exercise : Identify Entity & VO in ACME Sales Model

Lecture 36 Hands On : Building the ACME Sales Entities & VO in JAVA

Lecture 37 Aggregate & Factory – Pattern

Lecture 38 Exercise : ACME Sales Use Case

Lecture 39 Hands On : UML for ACME Sales Aggregates

Lecture 40 Model Behavior : Anemic & Rich Models

Lecture 41 Repository Object – Pattern

Lecture 42 Hands On : ACME model Repository in UML & JAVA

Lecture 43 Domain Service – Pattern

Lecture 44 Application Services – Pattern

Lecture 45 Infrastructure Services – Pattern

Lecture 46 Hands On : ACME Domain Service, UML & JAVA

Lecture 47 Hands On : Application and Infrastructure Services, UML & JAVA

Section 8: Events Driven Architecture & Domain Events

Lecture 48 Intro to Events in Microservices

Lecture 49 Monolithic & Distributed Communication Patterns

Lecture 50 Microservices Interaction Patterns

Lecture 51 Event Driven Architecture

Lecture 52 Hands On : Pub Sub with AMQP/RabbitMQ

Lecture 53 Domain Events – Pattern

Lecture 54 Hands On : Static Class Broker Pattern

Lecture 55 Exercise : ACME Sales Domain Events

Lecture 56 Hands On : Realization of ACME Domain Events

Lecture 57 Integration Events – Pattern

Lecture 58 Exercise : ACME Sales Integration Events

Lecture 59 Hands On : Realization of ACME Integration Events (1 of 2)

Lecture 60 Hands On : Realization of ACME Integration Events (2 of 2)

Section 9: Event Storming for creating shared knowledge

Lecture 61 Learning Objectives : Discovering the Events in a Domain

Lecture 62 Introduction to Event Storming

Lecture 63 Elements of Event Storming

Lecture 64 Preparing for the ES Workshop

Lecture 65 Conducting the ES Workshop

Lecture 66 Exercise : ACME Sales ES Workshop

Section 10: Microservices Data Management Patterns

Lecture 67 Introduction to Microservices Data Persistence

Lecture 68 Monolithic Apps – Shared Persistence Storage

Lecture 69 Service Oriented Architecture (SOA)

Lecture 70 Separate Database pattern

Lecture 71 Brownfield Microservices : Database patterns | options

Lecture 72 Shared Database Pattern

Lecture 73 Shared Database : Challenges & Solutions

Section 11: Microservices DB Performance Management

Lecture 74 Need for more Data Patterns

Lecture 75 Commands Query Separation (CQS)

Lecture 76 Hands On : PostgreSQL Database for backend

Lecture 77 Realization of Commands & Queries

Lecture 78 Hands On : Build the CQS Pattern

Lecture 79 Command Query Responsibility Segregation (CQRS)

Lecture 80 Data Replication between WRITE-READ sides

Lecture 81 Exercise : ACME CQRS for Proposal

Lecture 82 Hands On : ACME CQRS command implementation

Lecture 83 Event Sourcing and Event Store considerations

Lecture 84 Hands On : MongoDB for ACME Sales READ side

Lecture 85 Hands On : CQRS-v1 Proposal Subscriber

Lecture 86 Hands On : CQRS-v2 Read side Query

Section 12: Microservices Managing the Data Integrity

Lecture 87 Introduction to Reliable Messaging

Lecture 88 Designing for Failure

Lecture 89 Exercise : Address ACME CQRS Write side failures

Lecture 90 Exercise : Address ACME CQRS Read side failures

Lecture 91 Hands On : Handling Duplicate Messages

Section 13: Microservices and Kafka

Lecture 92 Use of Kafka in Microservices

Lecture 93 Kafka Overview

Lecture 94 Kafka Concepts

Lecture 95 Hands On : Create a Kafka Cluster

Lecture 96 Hands On : Working with Kafka Producer

Lecture 97 Hands On : Working with Kafka Consumer Groups

Lecture 98 Kafka vs AMQP (RabbitMQ)

Lecture 99 Exercise : Messaging for Microservices

Section 14: Managing Distributed Transactions with SAGA

Lecture 100 Distributed Transactions with SAGA

Lecture 101 SAGA Pattern for distributed transactions

Lecture 102 SAGA Choreography Vs. Orchestration

Lecture 103 SAGA Implementation Considerations

Lecture 104 Exercise : ACME Sales Booking Transaction SAGA

Lecture 105 Hands On : UML & Code walkthrough of Booking SAGA

Section 15: Microservices and API

Lecture 106 Microservices-API Realization

Lecture 107 Introduction to REST API

Lecture 108 REST API Resources & Design constraints

Lecture 109 API Management

Lecture 110 Exercise : ACME REST API for Products

Lecture 111 Hands On : ACME REST API in action

Lecture 112 Introduction to GraphQL

Lecture 113 GraphQL Schema Definition

Lecture 114 Exercise : ACME GraphQL API for Products

Lecture 115 Hands On : ACME GraphQL API in action

Software Developers,Software Architects,Product Managers,Students interested in Microservices

Course Information:

Udemy | English | 12h 41m | 2.74 GB
Created by: Rajeev Sakhuja

You Can See More Courses in the Developer >> Greetings from

New Courses

Scroll to Top