BestHub
Sign in
Tagged articles

DDD

343 articles · Page 3 of 4
HomeTech
HomeTech
Sep 23, 2022 · Backend Development

Why Use Domain-Driven Design (DDD) and How to Apply It

The article explains why Domain-Driven Design (DDD) is valuable for handling complex business logic, compares it with traditional transaction‑script approaches, introduces core DDD concepts such as ubiquitous language, bounded contexts, entities, value objects, aggregates, factories, repositories and domain services, and provides practical steps and examples for adopting DDD in backend development.

DDDDesign PatternsDomain-Driven Design
0 likes · 12 min read
Why Use Domain-Driven Design (DDD) and How to Apply It
Top Architect
Top Architect
Sep 23, 2022 · Backend Development

Event‑Driven Architecture and Ensuring Eventual Consistency in Microservices

The article explores event‑driven architecture in microservices, detailing transaction consistency challenges, eventual consistency solutions, domain‑driven design, bounded contexts, and practical patterns such as local transaction tables, event sourcing, and materialized views to achieve reliable distributed systems.

DDDevent-driveneventual consistency
0 likes · 15 min read
Event‑Driven Architecture and Ensuring Eventual Consistency in Microservices
Top Architect
Top Architect
Sep 15, 2022 · Backend Development

Event‑Driven Architecture and Distributed Transaction Consistency in Microservices

The article explains how traditional ACID transaction guarantees break down in microservice environments, discusses the challenges of distributed transactions, and presents event‑driven architectures, eventual consistency, domain services, materialized views, and practical patterns such as local transaction tables and event sourcing to achieve reliable consistency across services.

DDDarchitectureevent-driven
0 likes · 15 min read
Event‑Driven Architecture and Distributed Transaction Consistency in Microservices
Wukong Talks Architecture
Wukong Talks Architecture
Aug 17, 2022 · Cloud Native

Enterprise Business Middle Platform Architecture and Implementation at Dongfang Securities

The article presents a comprehensive overview of Dongfang Securities' enterprise business middle platform, detailing its background, definition, construction principles, user journey, overall architecture, domain‑driven design, technical stack, service governance, PaaS, multi‑active deployment, R&D management, data governance, and the practical outcomes achieved through this cloud‑native transformation.

DDDPaaSService Governance
0 likes · 22 min read
Enterprise Business Middle Platform Architecture and Implementation at Dongfang Securities
Zhuanzhuan Tech
Zhuanzhuan Tech
Aug 12, 2022 · Backend Development

Objective Understanding of DDD and Its Practice in ZuanZuan Pricing System

This article objectively explains Domain‑Driven Design, compares it with traditional data‑driven approaches, and details how DDD was applied in the architecture, strategic and tactical design, context integration, and business‑logic implementation of ZuanZuan's complex pricing system, including code examples.

DDDJavasoftware architecture
0 likes · 13 min read
Objective Understanding of DDD and Its Practice in ZuanZuan Pricing System
ITFLY8 Architecture Home
ITFLY8 Architecture Home
Aug 8, 2022 · Backend Development

Mastering DDD: How Domain‑Driven Design Reshapes Your Project Architecture

Domain‑Driven Design (DDD) transforms traditional three‑tier development by introducing a unified domain model, clear bounded contexts, and tactical patterns like aggregates and value objects, enabling teams to separate business complexity from technical concerns, improve collaboration, and build more maintainable, adaptable software architectures.

DDDbackend developmentlayered architecture
0 likes · 8 min read
Mastering DDD: How Domain‑Driven Design Reshapes Your Project Architecture
IT Architects Alliance
IT Architects Alliance
Aug 7, 2022 · Backend Development

Why CQRS Matters: Evolving Monoliths into Scalable Systems

This article walks through the evolution from a traditional monolithic architecture to a CQRS‑based design, explaining the motivations, trade‑offs, and concrete techniques such as read‑write separation, message‑driven commands, eventual consistency, and event sourcing for building more scalable and maintainable systems.

CQRSCQSDDD
0 likes · 12 min read
Why CQRS Matters: Evolving Monoliths into Scalable Systems
ITFLY8 Architecture Home
ITFLY8 Architecture Home
Aug 6, 2022 · Backend Development

Why CQRS Matters: Evolving From Monolithic to Scalable Architecture

This article walks through the evolution of software design from a traditional monolithic API server to a CQRS-based architecture, highlighting the drawbacks of the anemic CRUD model, the benefits of read/write separation, domain messaging, eventual consistency, and practical implementation considerations.

CQRSDDDRead-Write Separation
0 likes · 9 min read
Why CQRS Matters: Evolving From Monolithic to Scalable Architecture
ITPUB
ITPUB
Jul 18, 2022 · Backend Development

Designing Flexible Go Repositories with DDD: Interfaces, Implementations, and Snapshots

This article explains how to persist domain entities using DDD‑driven repositories in Go, covering value objects vs. entities, repository interface design, method naming conventions, single‑ and multi‑table implementations, and snapshot‑based change detection to handle evolving storage requirements.

DDDGoPersistence
0 likes · 14 min read
Designing Flexible Go Repositories with DDD: Interfaces, Implementations, and Snapshots
ITPUB
ITPUB
Jul 8, 2022 · Fundamentals

Why Entities Matter in DDD: Understanding Identity, Uniqueness, and Aggregate Roots

This article explains the core DDD concepts of entities, value objects, and aggregate roots in Go, detailing how unique identifiers differ from database primary keys, when to use value objects versus primitive types, and best practices for generating and handling IDs within aggregates.

Aggregate RootDDDEntity
0 likes · 17 min read
Why Entities Matter in DDD: Understanding Identity, Uniqueness, and Aggregate Roots
macrozheng
macrozheng
Jul 6, 2022 · Backend Development

Master Domain-Driven Design: From Theory to a Complete Java DDD Demo

This article explains the fundamentals of Domain‑Driven Design, compares it with traditional MVC, details layered architecture, data transformation objects, core concepts like aggregates and domain events, and provides a full Java SpringBoot DDD demo with code, project structure, database schema, and deployment steps.

DDDDomain-Driven DesignJava
0 likes · 32 min read
Master Domain-Driven Design: From Theory to a Complete Java DDD Demo
NetEase Yanxuan Technology Product Team
NetEase Yanxuan Technology Product Team
Jun 20, 2022 · Backend Development

DDD Practice in E-commerce Product Center Middle-Platform Service Construction

The article details how NetEase Yanxuan applied Domain‑Driven Design to reconstruct its Product Center middle‑platform, using strategic and tactical design, COLA layered architecture, and an event‑driven mechanism to eliminate duplicated logic and heavy coupling, cutting code volume by roughly two‑thirds while addressing entity scope, model richness, and microservice granularity challenges.

COLA ArchitectureDDDDomain-Driven Design
0 likes · 12 min read
DDD Practice in E-commerce Product Center Middle-Platform Service Construction
ITPUB
ITPUB
Jun 17, 2022 · Backend Development

How to Design DDD Code Implementation Models: A Practical Guide with Real-World Example

This article explains how to translate complex Domain‑Driven Design concepts into concrete code structures, covering domain objects, application services, infrastructure, and context integration, and demonstrates the approach with a ticket‑service case study using Spring Boot and Spring Cloud Stream.

DDDDomain-Driven DesignSpring Boot
0 likes · 14 min read
How to Design DDD Code Implementation Models: A Practical Guide with Real-World Example
Qunar Tech Salon
Qunar Tech Salon
May 5, 2022 · Backend Development

Applying Domain-Driven Design (DDD) to Hotel Transaction Systems: Architecture and Code Implementation

This article explains how Domain-Driven Design is applied to a hotel transaction platform, detailing a four‑layer loose DDD architecture, the responsibilities of each layer, code implementation examples, and strategies for maintaining consistency across aggregates using events and factories.

DDDDomain-Driven DesignHotel Transaction
0 likes · 9 min read
Applying Domain-Driven Design (DDD) to Hotel Transaction Systems: Architecture and Code Implementation
HomeTech
HomeTech
Apr 20, 2022 · Backend Development

How to Build a Clean DDD Microservice Architecture: Layers, Naming Rules, and Code Model

This article walks through constructing a welfare‑center microservice using Domain‑Driven Design, detailing a four‑layer architecture, strict naming conventions for POJOs, method naming rules, code‑style guidelines, directory layout, and concrete Java examples for adapters, services, domain objects, and infrastructure components.

DDDDomain-Driven DesignJava
0 likes · 16 min read
How to Build a Clean DDD Microservice Architecture: Layers, Naming Rules, and Code Model
政采云技术
政采云技术
Apr 7, 2022 · Fundamentals

Applying Architectural Patterns to Monolith Splitting and System Scalability: Lessons from "Software Architecture with Patterns"

This article reviews key concepts from the book "Software Architecture with Patterns" and discusses how architectural patterns such as layered architecture, microkernel, and GoF design patterns can guide the decomposition of monolithic applications and improve the extensibility of complex systems.

DDDDesign PatternsMicrokernel
0 likes · 15 min read
Applying Architectural Patterns to Monolith Splitting and System Scalability: Lessons from "Software Architecture with Patterns"
Top Architect
Top Architect
Apr 2, 2022 · Backend Development

Applying Domain-Driven Design to Payment Systems: A Comprehensive Guide

This article explains how Airwallex uses Domain-Driven Design (DDD) to model a complex payment system, detailing strategic and tactical patterns, bounded contexts, domain events, and the translation of domain models into microservice architectures, while highlighting the benefits of clear communication and modular design.

DDDDomain-Driven Designbackend development
0 likes · 9 min read
Applying Domain-Driven Design to Payment Systems: A Comprehensive Guide
HomeTech
HomeTech
Mar 30, 2022 · Backend Development

Applying DDD and Event‑Storming to Design a Welfare Center Microservice

This article explains how to replace a traditional three‑tier architecture with a DDD‑based four‑layer microservice design for a welfare‑center system, detailing the advantages and drawbacks of each approach, the event‑storming process for domain modeling, and the construction of entities, aggregates, aggregate roots, domain events, and bounded contexts.

DDDEvent Stormingdomain modeling
0 likes · 12 min read
Applying DDD and Event‑Storming to Design a Welfare Center Microservice
Qunar Tech Salon
Qunar Tech Salon
Mar 23, 2022 · Backend Development

Case Study: DDD‑Driven Architectural Refactoring of the Hotel Pricing System at Qunar

This case study details how Qunar’s hotel pricing platform was reorganized in 2021 using Domain‑Driven Design and explicit architecture principles to streamline cross‑team collaboration, reduce data‑flow complexity, and improve response time by 25%, while aligning system structure with Conway’s Law.

Conway's lawDDDDomain-Driven Design
0 likes · 14 min read
Case Study: DDD‑Driven Architectural Refactoring of the Hotel Pricing System at Qunar
LOFTER Tech Team
LOFTER Tech Team
Mar 15, 2022 · Mobile Development

Applying Domain‑Driven Design to Large List Architecture in Android

This article describes how the Lofter team applied Domain‑Driven Design to refactor and govern complex, multi‑type RecyclerView lists on Android, progressing from a monolithic adapter through a split‑stage implementation to a full DDD‑based framework with reusable bars and context‑aware layout managers.

AndroidDDDLarge List
0 likes · 22 min read
Applying Domain‑Driven Design to Large List Architecture in Android
Architecture Digest
Architecture Digest
Mar 9, 2022 · Fundamentals

Domain-Driven Design: Concepts, Bounded Contexts, and Architectural Patterns

This article introduces Domain-Driven Design (DDD), explains key terminology, describes the evolution of architecture from SaaS to IaaS, details bounded context concepts and division rules, and reviews major architectural styles such as clean layered, hexagonal, and onion architectures for building robust software systems.

DDDDomain-Driven Designbounded-context
0 likes · 9 min read
Domain-Driven Design: Concepts, Bounded Contexts, and Architectural Patterns
ByteFE
ByteFE
Mar 4, 2022 · Frontend Development

Tech Article Recommendations: MDN Redesign, Taro, Vite, DDD, State Machine, Flutter, GIF, Node.js Streams, Browser Inline Import, Frontend Drag-and-Drop

This post curates a variety of technical article recommendations covering frontend innovations like MDN's redesign, Taro, Vite, state‑based architecture, and drag‑and‑drop, plus backend Node.js streams, mobile Flutter, and cross‑platform insights for developers seeking to stay updated.

DDDDrag-and-DropFlutter
0 likes · 5 min read
Tech Article Recommendations: MDN Redesign, Taro, Vite, DDD, State Machine, Flutter, GIF, Node.js Streams, Browser Inline Import, Frontend Drag-and-Drop
phodal
phodal
Feb 28, 2022 · Backend Development

Why We Chose a Monolithic Architecture Over Microservices for ArchGuard

The team behind the open‑source ArchGuard platform recounts their migration from Maven to Gradle, library updates, and a surprising shift from a microservice‑based system to a monolithic architecture, explaining the challenges of legacy services, the principles guiding service granularity, and the practical benefits of a single‑code‑base deployment for a small open‑source project.

DDDSoftware Engineeringmigration
0 likes · 8 min read
Why We Chose a Monolithic Architecture Over Microservices for ArchGuard
dbaplus Community
dbaplus Community
Feb 9, 2022 · Databases

From DDD to Database Design: Transforming Relational and NoSQL Schemas

This article explains how domain‑driven design shifts database modeling from a data‑structure‑first approach to a domain‑model‑centric process, covering persistence of domain objects, the conversion of the four classic relational relationships and inheritance into tables, and the distinct strategies required for NoSQL databases.

DDDDomain ModelInheritance
0 likes · 18 min read
From DDD to Database Design: Transforming Relational and NoSQL Schemas
JD Retail Technology
JD Retail Technology
Jan 19, 2022 · Backend Development

Applying Domain-Driven Design and Polymorphic Architecture to E‑commerce Product Detail Pages

This article shares practical experience of using Domain‑Driven Design to refactor an e‑commerce product detail page, detailing domain decomposition, relationship‑network design, polymorphic logic handling, and two concrete case studies that illustrate how to support both online and offline sales scenarios with minimal impact on existing services.

DDDDomain-Driven DesignPolymorphism
0 likes · 13 min read
Applying Domain-Driven Design and Polymorphic Architecture to E‑commerce Product Detail Pages
Baidu Geek Talk
Baidu Geek Talk
Jan 5, 2022 · Backend Development

AiFanFan Communication System Refactoring: Challenges, Design, and Implementation

The AiFanFan Communication system was refactored by applying domain‑driven design and micro‑services, replacing an outdated Windows C++ client and excessive middleware with a five‑layer architecture, streamlined protocols, and a cross‑platform Electron‑Vue UI, resulting in clearer modules, higher stability, reduced team size, and faster feature delivery.

BackendDDDProduct Redesign
0 likes · 29 min read
AiFanFan Communication System Refactoring: Challenges, Design, and Implementation
Youzan Coder
Youzan Coder
Dec 31, 2021 · Backend Development

Applying Domain-Driven Design (DDD) in Youzan Credit Core System

Applying Domain‑Driven Design to Youzan’s Credit Core System involved consulting experts, mapping loan processes, using four‑color modeling to define documents, participants, roles and data, establishing bounded contexts, designing sub‑domains with use‑case diagrams, and adopting a layered (often hexagonal) architecture to ensure maintainable, scalable microservices.

DDDDomain-Driven DesignLoan System
0 likes · 6 min read
Applying Domain-Driven Design (DDD) in Youzan Credit Core System
HelloTech
HelloTech
Nov 30, 2021 · Backend Development

Applying Domain-Driven Design and Microservice Architecture in E-commerce Business

The talk demonstrates how to apply Domain‑Driven Design and microservice architecture to an e‑commerce voucher platform by defining problem spaces and bounded contexts, prioritizing boundaries over aggregates, using layered‑on‑demand infrastructure, and following SOLID principles to achieve clear, maintainable services.

DDDDomain-Driven Designdesign principles
0 likes · 12 min read
Applying Domain-Driven Design and Microservice Architecture in E-commerce Business
Architecture Digest
Architecture Digest
Nov 27, 2021 · Fundamentals

Key Insights into Domain-Driven Design (DDD)

This article shares personal notes and a mind‑map on Domain‑Driven Design, explaining effective modeling elements, knowledge digestion, continuous learning, and deep modeling to help development teams build structured, collaborative domain models that align code with business logic.

DDDDomain-Driven DesignKnowledge Management
0 likes · 11 min read
Key Insights into Domain-Driven Design (DDD)
Architects Research Society
Architects Research Society
Nov 25, 2021 · Backend Development

Practical Implementation of Domain‑Driven Design with a Loan Processing Sample Application

This article provides a comprehensive, practical guide to applying Domain‑Driven Design (DDD) in enterprise Java projects, covering architectural principles, project management steps, design patterns, code generation, testing, deployment, and a detailed loan‑processing example that demonstrates how to model, implement, and evolve a rich domain model using Spring, DI, AOP, and related technologies.

DDDDomain-Driven DesignJava
0 likes · 39 min read
Practical Implementation of Domain‑Driven Design with a Loan Processing Sample Application
IT Architects Alliance
IT Architects Alliance
Nov 14, 2021 · Fundamentals

What Is Architecture Design? Principles, Goals, Methods, and Common System Architectures

This article explains architecture design, covering its definition, core principles, goals, the 4+1 view method, classifications of monolithic and distributed architectures, common system architecture patterns, business analysis techniques, domain‑driven design, DSL concepts, and organizational structures for development teams.

DDDSystem Designdesign principles
0 likes · 13 min read
What Is Architecture Design? Principles, Goals, Methods, and Common System Architectures
Full-Stack Internet Architecture
Full-Stack Internet Architecture
Nov 5, 2021 · Backend Development

Understanding Domain-Driven Design (DDD): Concepts, Design Process, and Architectural Practices

This article explains the fundamentals of Domain-Driven Design, covering its core concepts, step‑by‑step design methodology, domain modeling techniques, and how to apply DDD in microservice architectures with considerations for technical elements such as distributed transactions and scalability.

DDDDomain-Driven Designbackend development
0 likes · 7 min read
Understanding Domain-Driven Design (DDD): Concepts, Design Process, and Architectural Practices
Programmer DD
Programmer DD
Oct 29, 2021 · Backend Development

How Keep Revamped Its E‑Commerce Supply Chain with DDD and EventStore

This article details Keep’s practical application of Domain‑Driven Design to overhaul its e‑commerce supply‑chain system, describing the legacy challenges, the step‑by‑step DDD restructuring—including inventory modeling, bounded contexts, hexagonal architecture, CQRS, event sourcing, and testing—plus the resulting benefits and best‑practice insights.

DDDEvent SourcingJava
0 likes · 9 min read
How Keep Revamped Its E‑Commerce Supply Chain with DDD and EventStore
IT Architects Alliance
IT Architects Alliance
Oct 17, 2021 · Fundamentals

Why Domain-Driven Design (DDD) Became Popular and Its Role in Microservices

The article explains how Domain-Driven Design (DDD) rose to prominence by addressing business‑boundary challenges in microservice architectures, outlines the evolution of software architectures, and details DDD’s strategic and tactical design practices for creating clear, maintainable service boundaries.

DDDDomain-Driven DesignStrategic Design
0 likes · 9 min read
Why Domain-Driven Design (DDD) Became Popular and Its Role in Microservices
Architecture Digest
Architecture Digest
Oct 12, 2021 · Fundamentals

Introduction to Domain-Driven Design (DDD)

This article provides a concise overview of Domain-Driven Design, explaining why it matters, defining key concepts such as domain, model, bounded context, and ubiquitous language, and illustrating how DDD helps teams tackle core software complexity through collaborative modeling and shared terminology.

DDDDomain-Driven Designsoftware architecture
0 likes · 11 min read
Introduction to Domain-Driven Design (DDD)
IT Architects Alliance
IT Architects Alliance
Oct 7, 2021 · Backend Development

Applying DDD to Refactor Keep's E‑commerce Supply‑Chain System

This article describes how Keep used Domain‑Driven Design, bounded contexts, hexagonal architecture, CQRS, and an EventStore‑based event‑sourcing solution to rebuild its legacy supply‑chain (inventory) system, improve inventory accuracy, simplify extensions, and establish a reusable DDD practice for future micro‑service development.

DDDEvent SourcingSupply Chain
0 likes · 7 min read
Applying DDD to Refactor Keep's E‑commerce Supply‑Chain System
Architect
Architect
Oct 5, 2021 · Fundamentals

Understanding Entities and Value Objects in Domain‑Driven Design: Why a Message Should Be an Entity and Contacts Should Be Treated as Entities

The article explains the core characteristics of entities—identity and continuity—using DDD concepts, demonstrates why a Message in a messaging scenario qualifies as an entity, and argues that senders and recipients (contacts) should also be modeled as entities rather than value objects.

DDDDomain-Driven DesignEntity
0 likes · 12 min read
Understanding Entities and Value Objects in Domain‑Driven Design: Why a Message Should Be an Entity and Contacts Should Be Treated as Entities
Architecture Digest
Architecture Digest
Oct 1, 2021 · Backend Development

Refactoring a Legacy Supply‑Chain System with DDD, Hexagonal Architecture, and EventStore

The article details how a legacy e‑commerce supply‑chain system plagued by unclear boundaries, inventory inaccuracies, and tangled dependencies was redesigned using domain‑driven design, hexagonal architecture, CQRS, and an EventStore solution, resulting in accurate inventory, easier extensions, and a reusable event‑driven component.

BackendDDDEvent Sourcing
0 likes · 10 min read
Refactoring a Legacy Supply‑Chain System with DDD, Hexagonal Architecture, and EventStore
ITFLY8 Architecture Home
ITFLY8 Architecture Home
Sep 30, 2021 · Backend Development

How DDD and Event Sourcing Revamped a Legacy Supply‑Chain System

This article details how a tangled, legacy supply‑chain system was re‑engineered using domain‑driven design, hexagonal architecture, CQRS, and an EventStore solution, resulting in accurate inventory, clearer boundaries, easier extensions, and a reusable event‑driven component for future e‑commerce projects.

DDDEvent Sourcingbackend architecture
0 likes · 10 min read
How DDD and Event Sourcing Revamped a Legacy Supply‑Chain System
YunZhu Net Technology Team
YunZhu Net Technology Team
Sep 23, 2021 · Backend Development

ABP vNext Framework: Overview, Features, and Step‑by‑Step Guide to Building a .NET Microservice Application

This article introduces the ABP vNext framework, explains its origins from ASP.NET Boilerplate, details its modular, DDD‑based architecture and microservice capabilities, and provides a complete hands‑on tutorial—including CLI commands, project structure, code snippets, and best‑practice recommendations—for creating a .NET microservice solution.

.NETABPDDD
0 likes · 17 min read
ABP vNext Framework: Overview, Features, and Step‑by‑Step Guide to Building a .NET Microservice Application
ByteFE
ByteFE
Sep 15, 2021 · Frontend Development

Why DDD Is Needed and How to Apply Domain-Driven Design in Front‑End Projects

The article explains the need for Domain‑Driven Design (DDD) to manage growing complexity caused by frequent requirement changes, describes DDD fundamentals such as bounded contexts and event storming, and shows how to structure React front‑end code, actions, reducers, and routing by organizing features to reduce coupling and improve maintainability.

DDDDomain-Driven DesignEvent Storming
0 likes · 11 min read
Why DDD Is Needed and How to Apply Domain-Driven Design in Front‑End Projects
IT Architects Alliance
IT Architects Alliance
Sep 12, 2021 · Fundamentals

Fundamentals of Domain‑Driven Design: Core Concepts, Building Blocks, and Architectural Patterns

This article introduces the essential principles of Domain‑Driven Design, explaining its two‑stage approach, key building blocks such as entities, value objects, aggregates, factories, repositories, services, and domain events, and shows how DDD fits into layered architecture and common anti‑patterns.

AggregatesDDDDomain Model
0 likes · 26 min read
Fundamentals of Domain‑Driven Design: Core Concepts, Building Blocks, and Architectural Patterns
Architects Research Society
Architects Research Society
Sep 5, 2021 · Fundamentals

An Introduction to Domain-Driven Design (DDD) Patterns and Practices

This article explains the core concepts, patterns, and architectural styles of Domain-Driven Design, covering model‑driven design, bounded contexts, layered and hexagonal architectures, building blocks such as entities, value objects, aggregates, repositories, factories, and services, with practical examples and diagrams.

BackendDDDDomain-Driven Design
0 likes · 28 min read
An Introduction to Domain-Driven Design (DDD) Patterns and Practices
DevOps
DevOps
Aug 31, 2021 · Backend Development

Designing an Uber‑Like Microservice System with DDD, OpenTelemetry Observability, and Reinforced Chaos Engineering

This article describes how to model a complex Uber‑style ride‑hailing system using Domain‑Driven Design, implement it with Java Spring Boot microservices, instrument it with OpenTelemetry for full observability, and validate the observability pipeline through a gamified chaos‑engineering approach that reduces MTTR.

DDDJavaOpenTelemetry
0 likes · 13 min read
Designing an Uber‑Like Microservice System with DDD, OpenTelemetry Observability, and Reinforced Chaos Engineering
Programmer DD
Programmer DD
Aug 18, 2021 · Fundamentals

Why Domain-Driven Design Remains Essential for Complex Software Projects

Domain-Driven Design (DDD) focuses software development on deep domain understanding, offering a proven, timeless approach to tackling core complexity, especially in large or evolving systems, while emphasizing the crucial role of a well‑crafted domain model and DSL.

DDDDSLDomain-Driven Design
0 likes · 9 min read
Why Domain-Driven Design Remains Essential for Complex Software Projects
IT Architects Alliance
IT Architects Alliance
Aug 16, 2021 · Backend Development

Applying Layered Architecture and DDD to Microservice System Design

The article presents a practical approach to designing complex microservice systems by combining layered architecture with Domain‑Driven Design, outlining a five‑layer model, detailing each layer’s responsibilities, offering domain‑splitting guidelines, and illustrating implementation with code examples and development steps.

DDDSoftware EngineeringSystem Design
0 likes · 25 min read
Applying Layered Architecture and DDD to Microservice System Design
dbaplus Community
dbaplus Community
Aug 9, 2021 · Backend Development

Applying Domain‑Driven Design in Haro’s Transaction Platform: Key Lessons

This article explains the fundamentals of Domain‑Driven Design (DDD), outlines its strategic and tactical design processes, and demonstrates how Haro’s transaction platform applies DDD across taxi, e‑commerce, and core trading scenarios, highlighting benefits, challenges, and practical recommendations.

DDDDomain-Driven DesignTransaction Platform
0 likes · 29 min read
Applying Domain‑Driven Design in Haro’s Transaction Platform: Key Lessons
Programmer DD
Programmer DD
Aug 6, 2021 · Backend Development

How Domain‑Driven Design Powers Scalable Microservices Architecture

This article explains how Domain‑Driven Design provides a systematic approach to modeling complex business domains, guiding microservice decomposition, service boundaries, bounded contexts, and layered architectures, while addressing software complexity through strategic and tactical patterns such as SOLID, aggregates, and hexagonal design.

DDDDomain-Driven DesignService Splitting
0 likes · 19 min read
How Domain‑Driven Design Powers Scalable Microservices Architecture
Ctrip Technology
Ctrip Technology
Aug 5, 2021 · Backend Development

Applying Domain-Driven Design and Hexagonal Architecture in Ctrip International Train Ticket Booking System

This article presents a practical implementation of Domain-Driven Design (DDD) and hexagonal architecture in Ctrip's international train ticket booking platform, detailing strategic and tactical design, addressing controller bloat, over‑coupling, and anemic models, and showcasing Java code examples for aggregates, repositories, and factories.

DDDJavadomain modeling
0 likes · 17 min read
Applying Domain-Driven Design and Hexagonal Architecture in Ctrip International Train Ticket Booking System
ByteDance Web Infra
ByteDance Web Infra
Jul 23, 2021 · Backend Development

Design and Refactoring of ByteDance's Node.js RPC Framework

This article explains the motivation, design principles, model architecture, and implementation challenges of rebuilding ByteDance's Node.js RPC system, covering DDD‑based decomposition, protocol and connection abstractions, multi‑protocol nesting, client/server creation APIs, and performance‑optimized context extensions.

DDDNode.jsPerformance
0 likes · 14 min read
Design and Refactoring of ByteDance's Node.js RPC Framework
Miss Fresh Tech Team
Miss Fresh Tech Team
Jul 7, 2021 · Backend Development

How DDD Transforms Complex Store Systems: From Monolith to Scalable Microservices

This article explores how Domain‑Driven Design (DDD) was applied to redesign a rapidly evolving retail store system, detailing the challenges of legacy monoliths, the step‑by‑step migration through versions 1.0, 2.0 and 3.0, and the resulting architectural, tactical and operational benefits for backend development.

DDDDomain-Driven DesignSpring Cloud
0 likes · 41 min read
How DDD Transforms Complex Store Systems: From Monolith to Scalable Microservices
ITFLY8 Architecture Home
ITFLY8 Architecture Home
Jul 1, 2021 · Fundamentals

What a Peach Tree Can Teach You About Domain‑Driven Design

This article uses a peach‑tree analogy to explain how to break down complex business logic into domains, subdomains, core, generic, and supporting domains, illustrating the practical steps and benefits of applying Domain‑Driven Design in software projects.

DDDdomain modelingmicroservices
0 likes · 8 min read
What a Peach Tree Can Teach You About Domain‑Driven Design
Architecture Digest
Architecture Digest
Jun 28, 2021 · Backend Development

Why Domain-Driven Design (DDD) Became Popular and How It Solves Microservice Boundary Challenges

The article explains the rise of Domain-Driven Design by tracing architectural evolution from monolithic to microservices, highlighting DDD’s role in defining business boundaries, its strategic and tactical components, and practical steps for modeling domains to guide microservice design.

DDDDomain-Driven Designbackend development
0 likes · 11 min read
Why Domain-Driven Design (DDD) Became Popular and How It Solves Microservice Boundary Challenges
Alibaba Cloud Developer
Alibaba Cloud Developer
Jun 22, 2021 · Backend Development

Mastering DDD Aggregates: When and How to Define Boundaries

This article explains the purpose of aggregates in Domain‑Driven Design, illustrates common pitfalls with database‑centric and naïve OO models, and provides practical heuristics and implementation guidelines—including lifecycle, domain, and scenario consistency—to help developers design clean, consistent aggregates.

AggregatesDDDDomain-Driven Design
0 likes · 22 min read
Mastering DDD Aggregates: When and How to Define Boundaries
Alibaba Cloud Developer
Alibaba Cloud Developer
Jun 16, 2021 · Backend Development

Mastering DDD Aggregates: Defining Boundaries for Consistent Design

This article explains the essence of DDD aggregates, why they are needed to enforce business consistency, how to identify proper aggregate boundaries using lifecycle, domain, and scenario‑frequency rules, and provides practical implementation guidance with code examples and architectural tips.

AggregatesDDDDomain-Driven Design
0 likes · 22 min read
Mastering DDD Aggregates: Defining Boundaries for Consistent Design
Top Architect
Top Architect
Jun 14, 2021 · Backend Development

Microservice Communication: RPC vs Event‑Driven, Event Sourcing, and Design Strategies

The article examines microservice communication methods, comparing RPC and event‑driven approaches, explains different coupling types, introduces event notification and event sourcing, discusses API gateways, service composition, internal microservice design, and offers practical guidance for reducing tight coupling and managing service scale.

API-gatewayDDDRPC
0 likes · 19 min read
Microservice Communication: RPC vs Event‑Driven, Event Sourcing, and Design Strategies
Architecture Digest
Architecture Digest
May 25, 2021 · Backend Development

Layered Architecture and Domain‑Driven Design for Java Fresh‑Food E‑Commerce Microservices

This article presents a practical approach to applying layered architecture and Domain‑Driven Design (DDD) in a Java‑based fresh‑food e‑commerce platform, outlining a five‑layer microservice structure, domain partitioning guidelines, and common pitfalls to help teams build maintainable, scalable systems.

DDDJavae-commerce
0 likes · 18 min read
Layered Architecture and Domain‑Driven Design for Java Fresh‑Food E‑Commerce Microservices
Qunar Tech Salon
Qunar Tech Salon
May 20, 2021 · Backend Development

Rebuilding a Hotel Pricing Engine with Domain-Driven Design: A Qunar Case Study

The article describes how Qunar's technical director Zheng Jimin applied Domain‑Driven Design to refactor the hotel pricing engine, dramatically improving development efficiency, reducing onboarding time, and aligning product and engineering through a three‑stage strategic, tactical, and implementation process.

DDDDomain-Driven DesignHotel Pricing Engine
0 likes · 7 min read
Rebuilding a Hotel Pricing Engine with Domain-Driven Design: A Qunar Case Study
Alibaba Cloud Developer
Alibaba Cloud Developer
May 17, 2021 · Fundamentals

Why OOP Struggles with Complex Game Logic and How DDD/ECS Help

This article examines the limitations of classic object‑oriented programming for intricate game rules, demonstrates a dragon‑and‑magic example, compares OOP, Entity‑Component‑System and Domain‑Driven Design approaches, and provides practical guidelines, code snippets, and design patterns to achieve extensible, maintainable architecture.

DDDDesign PatternsECS
0 likes · 39 min read
Why OOP Struggles with Complex Game Logic and How DDD/ECS Help
JD Retail Technology
JD Retail Technology
May 11, 2021 · Backend Development

Redesigning JD's C‑End Invoice System: Architecture Upgrade, Performance Optimizations, and Future Roadmap

The article details JD's transition from a fragmented C‑end invoice service to a unified Invoice Center, describing the original user‑experience and architectural flaws, the DDD‑based layered redesign, performance‑boosting data and file‑handling strategies, achieved operational gains, and the planned next‑year initiatives.

DDDData Storageinvoice system
0 likes · 10 min read
Redesigning JD's C‑End Invoice System: Architecture Upgrade, Performance Optimizations, and Future Roadmap
Alibaba Cloud Developer
Alibaba Cloud Developer
Apr 28, 2021 · Backend Development

How to Refactor Monolithic Checkout Code into Clean DDD Modules

This article explains how to identify and refactor typical “流水账” (spaghetti) code in a checkout API by applying Domain‑Driven Design layers—splitting responsibilities into Interface, Application, and Domain layers, using CQE objects, DTO assemblers, and anti‑corruption facades to achieve clear, maintainable modules.

Application ServiceCQEDDD
0 likes · 32 min read
How to Refactor Monolithic Checkout Code into Clean DDD Modules
Baidu Geek Talk
Baidu Geek Talk
Apr 28, 2021 · Fundamentals

DDD Practice and Exploration at Baidu Aifanfan

The article recounts Baidu Aifanfan’s year‑long journey of exploring, promoting, and fully implementing Domain‑Driven Design—addressing Chinese developers’ limited DDD exposure, illustrating its fit with micro‑service and platform architectures, and offering practical insights on its value, suitable projects, team requirements, and impact on development practices.

DDDDomain-Driven Designproduct development
0 likes · 23 min read
DDD Practice and Exploration at Baidu Aifanfan
phodal
phodal
Apr 19, 2021 · Fundamentals

Unlocking Pattern Languages: From Design Patterns to Architecture

This article explores the concept of patterns and pattern languages across software design, architecture, and domain-driven design, detailing their definitions, classifications, practical usage, and examples such as POSA, microservice patterns, and elemental design patterns to help engineers systematically solve recurring problems.

DDDDesign PatternsPOSA
0 likes · 13 min read
Unlocking Pattern Languages: From Design Patterns to Architecture
IT Architects Alliance
IT Architects Alliance
Apr 10, 2021 · Backend Development

DDD Layered Architecture Patterns: Four‑Layer, Five‑Layer, and Hexagonal Approaches

This article reviews the fundamentals of Domain‑Driven Design and layered architecture, explains the role of ubiquitous language and bounded contexts, and compares three classic DDD layering patterns—four‑layer, five‑layer, and hexagonal—highlighting their practical definitions, benefits, drawbacks, and evolution for microservice‑based systems.

DDDsoftware design
0 likes · 19 min read
DDD Layered Architecture Patterns: Four‑Layer, Five‑Layer, and Hexagonal Approaches
Architect
Architect
Apr 8, 2021 · Fundamentals

Understanding Layered Architecture: Strict, Relaxed, and Inheritance Approaches

The article explains various layered architecture models—including strict, relaxed, and inheritance‑based approaches—detailing their coupling rules, implementation guidelines, code examples, and evolution through multi‑layered system designs, especially within domain‑driven design and modern front‑back separation.

BackendDDDarchitecture patterns
0 likes · 8 min read
Understanding Layered Architecture: Strict, Relaxed, and Inheritance Approaches
DeWu Technology
DeWu Technology
Mar 26, 2021 · Backend Development

Summary of DDD Layered Architecture for the Bidding Team

The Bidding Team’s DDD layered architecture consolidates all traffic in an Interfaces layer, uses a thin Application service layer to orchestrate use‑cases, places core business rules in Domain aggregates, isolates data access in Infrastructure, adds an Anti‑Corruption adapter, and employs DTOs, entities, and domain events for decoupled, consistent processing.

DDDDomain-Driven Designanti-corruption layer
0 likes · 12 min read
Summary of DDD Layered Architecture for the Bidding Team
DevOps
DevOps
Mar 26, 2021 · Fundamentals

From Software Engineering to Enterprise Architecture: Evolution of Design Methodologies and the Role of EBA and the Middle Platform

This article traces the evolution of software engineering and enterprise architecture, reviewing classic models like Waterfall, Zachman, TOGAF, Agile, DDD, and microservices, and examines how Enterprise Business Architecture (EBA) and the middle‑platform concept serve as integrative frameworks for modern digital transformation.

DDDEBAmicroservices
0 likes · 36 min read
From Software Engineering to Enterprise Architecture: Evolution of Design Methodologies and the Role of EBA and the Middle Platform
IT Architects Alliance
IT Architects Alliance
Mar 22, 2021 · Backend Development

Why Microservices Need DDD: Solving Complexity in Modern Systems

The article examines the limitations of microservice architectures, explains how Domain‑Driven Design (DDD) complements them by providing functional decomposition guidance, and presents a practical case study showing how clear bounded contexts and aggregate roots enable scalable, maintainable system splits.

DDDDomain-Driven Designmicroservices
0 likes · 9 min read
Why Microservices Need DDD: Solving Complexity in Modern Systems
Architecture Digest
Architecture Digest
Mar 22, 2021 · Fundamentals

DDD Layered Architecture: Four‑Layer, Five‑Layer, and Hexagonal Patterns

This article reviews Domain‑Driven Design and layered architecture fundamentals, then explains three classic DDD layered patterns—four‑layer, five‑layer, and hexagonal architectures—detailing their layers, responsibilities, advantages, drawbacks, and practical adaptations for microservice development.

DDDhexagonal-architecturelayered architecture
0 likes · 21 min read
DDD Layered Architecture: Four‑Layer, Five‑Layer, and Hexagonal Patterns
Yanxuan Tech Team
Yanxuan Tech Team
Mar 19, 2021 · Backend Development

How DDD Can Rescue a Decaying Warehouse Management System

This article examines the chronic decay of a complex warehouse inbound/outbound system, analyzes its tangled business logic and chaotic architecture, and presents a domain‑driven design solution with onion architecture, CQRS, and practical implementation steps to achieve clearer boundaries, higher cohesion, and sustainable evolution.

CQRSDDDOnion Architecture
0 likes · 15 min read
How DDD Can Rescue a Decaying Warehouse Management System
Architect
Architect
Mar 17, 2021 · Fundamentals

Understanding Domains, Subdomains, and Core Domains in Domain-Driven Design

This article explains the distinction between technical and business domains, defines domains and subdomains, describes how to identify core, generic, and supporting subdomains, and outlines practical methods such as domain vision statements and highlighted cores for effective domain‑driven design.

Core DomainDDDDomain-Driven Design
0 likes · 10 min read
Understanding Domains, Subdomains, and Core Domains in Domain-Driven Design
Alibaba Terminal Technology
Alibaba Terminal Technology
Mar 3, 2021 · Frontend Development

How We Solved Complex Frontend Data Flow with MobX and DDD

Facing tangled data flow, excessive template code, and scaling challenges in a large single‑page app, we analyzed business traits, identified pain points, and redesigned the architecture using layered stores, an API anti‑corruption layer, and domain‑driven design with MobX, achieving simpler, reusable, and maintainable front‑end code.

DDDMobXdata flow
0 likes · 12 min read
How We Solved Complex Frontend Data Flow with MobX and DDD
Architecture Digest
Architecture Digest
Mar 3, 2021 · Backend Development

Integrating Domain‑Driven Design with Microservices: Benefits, Drawbacks, and Practical Guidance

This article explains how Domain‑Driven Design complements microservice architecture by addressing functional partitioning, clarifying bounded contexts, and improving scalability, while also discussing microservice drawbacks and practical guidelines for splitting complex systems in modern applications.

DDDbackend architecturedomain modeling
0 likes · 9 min read
Integrating Domain‑Driven Design with Microservices: Benefits, Drawbacks, and Practical Guidance
Selected Java Interview Questions
Selected Java Interview Questions
Jan 19, 2021 · Backend Development

Designing a Monolithic Application for Future Microservice Migration: Best Practices and Code Structure

The article explains how to design a monolithic Java application with clear business boundaries, modular code organization, MVC layering, and disciplined controller logic so that it can be smoothly refactored into a micro‑service architecture, illustrating the approach with directory trees, package schemes, and sample CommonResult code.

DDDJavaMVC
0 likes · 11 min read
Designing a Monolithic Application for Future Microservice Migration: Best Practices and Code Structure
Qunar Tech Salon
Qunar Tech Salon
Jan 12, 2021 · Backend Development

Qunar 2020 Technical Article Collection: DDD, API, Backend, Infrastructure and System Design

This compilation presents Qunar's 2020 technical articles covering domain‑driven design, API standardization, backend services, Linux I/O, Redis distributed locks, GraphQL, JVM internals, and performance optimizations, offering detailed insights and practical guidance for engineers seeking to improve system architecture and operational efficiency.

APIBackendDDD
0 likes · 8 min read
Qunar 2020 Technical Article Collection: DDD, API, Backend, Infrastructure and System Design
iQIYI Technical Product Team
iQIYI Technical Product Team
Jan 8, 2021 · Backend Development

Domain-Driven Design (DDD) Practice in a Reward Service: Architecture, Strategic and Tactical Design

Applying Domain‑Driven Design and Hexagonal architecture to a reward service clarified domain boundaries, cut integration, middleware and onboarding costs by up to 30 %, streamlined unit‑test creation, and enabled a layered, framework‑independent codebase with entities, value objects, services, events, aggregates and factories that improve maintainability, scalability and testability.

DDDDomain-Driven DesignStrategic Design
0 likes · 15 min read
Domain-Driven Design (DDD) Practice in a Reward Service: Architecture, Strategic and Tactical Design