This article explains how to apply Domain-Driven Design (DDD) to a new project, detailing the evolution from monolithic to microservice architectures, the concepts of IaaS, PaaS, SaaS, bounded contexts, the four DDD boundaries, and clean, hexagonal, and onion architectural patterns.
This article introduces a modular backend service architecture based on Domain-Driven Design, explaining project structure, module composition, hexagonal architecture, and practical code examples using Spring Cloud, illustrating how to achieve flexible, maintainable services through domain models, adapters, and proper boundary definitions.
This article explains how to construct a reusable base package for backend systems by defining Maven dependency guidelines, a unified response body with business codes, proper data object layers such as PO, BO, DTO, VO, and pagination utilities, while illustrating the concepts with concrete Java code examples.
This article details how a large‑scale project environment platform was refactored using domain‑driven design, distributed sharding, thread‑pool parallelism, second‑level scheduling, and distributed locks to achieve over 99% creation success, reduce creation time below 100 seconds, and keep exception rates under 1% despite massive task volume.
This article presents a comprehensive case study of how Qunar's hotel supply‑chain team applied Domain‑Driven Design to restructure a decade‑old, highly coupled hotel information system, detailing the problem analysis, DDD rationale, evolutionary transformation process, architectural principles, implementation results, and lessons learned.
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.
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.
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.
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.
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.
This article explains how Domain‑Driven Design (DDD) differs from classic MVC layering, introduces core DDD terminology, compares anemic and rich domain models, and presents a practical multi‑layered DDD architecture with its concrete benefits for complex software systems.
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.
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.
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.
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.
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.
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.
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.
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.
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.
This article explains how to start a new project using Domain‑Driven Design, covering terminology, architecture evolution from monolith to microservices, bounded‑context concepts, four‑layer DDD boundaries, clean layered, hexagonal and onion architectures, and practical division rules.
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.
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.
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.
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.
This article explains how to start a new project using Domain‑Driven Design, covering terminology, architectural evolution across SaaS, PaaS and IaaS layers, bounded‑context division rules, the four DDD boundaries, clean layered, hexagonal and onion architectures, and their practical implications.
This article explains how to start a new project using Domain‑Driven Design, describes the evolution from SaaS to PaaS to IaaS, introduces bounded contexts, the four‑layer DDD boundaries, and compares clean, hexagonal, and onion architectures for building maintainable backend systems.
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.
In this interview, Qunar's technical director Zheng Jimin shares how the company revived Domain‑Driven Design to restructure hotel pricing, discusses strategic and tactical design, implementation challenges, success criteria, and the broader impact of technical influence on organizational growth.
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.
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.
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.
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.
This article provides a comprehensive overview of Domain-Driven Design (DDD), explaining its principles, strategic and tactical design, layered architecture, key objects such as entities, value objects, aggregates, and how DDD guides microservice and platform development.
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.
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.
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.
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.
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.
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.
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.
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.
The article explains the rise of Domain-Driven Design, its strategic and tactical design aspects, and how it helps define business boundaries to solve microservice decomposition challenges, providing a step‑by‑step approach for architects transitioning from monolithic to microservice systems.
The article explains how to decompose a business problem into domains, subdomains, core, generic, and supporting domains by using a peach tree analogy, illustrating the steps and reasons for such classification in Domain‑Driven Design and microservice architecture.
This article explains why, when, and how to split a monolithic application into microservices, covering the goals of splitting, timing decisions, guiding principles, granularity considerations, functional and non‑functional strategies, merging practices, and associated risks.
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.
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.
The article details how JD's Tongtian Tower platform transformed from a monolithic SOA to a domain‑driven, cloud‑native, multi‑tenant architecture using DDD, diamond symmetry design, PaaS/iPaaS, middleware decoupling, and a one‑click deployment solution, dramatically reducing site onboarding time.
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.
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.
This article explains how designing domain objects, services, and repositories as interfaces in Java enables seamless switching between different persistence technologies and deployment models, improving modularity, testability, and adaptability for micro‑service architectures.
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.
This article details how a legacy e‑commerce supply‑chain system was re‑architected using Domain‑Driven Design, Hexagonal architecture, CQRS, and an EventStore solution to resolve unclear boundaries, inventory inaccuracies, and scalability issues while improving testability and operational efficiency.
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.
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.
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.
This article describes how Keep leveraged Domain‑Driven Design, hexagonal architecture, CQRS and EventStore to restructure a legacy supply‑chain system, solve inventory inaccuracies, improve modularity, and achieve scalable, maintainable backend services for its e‑commerce platform.
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.
This article presents a comprehensive overview of how a team applied Domain-Driven Design to migrate a car‑purchase invoice repository, detailing DDD fundamentals, strategic and tactical design phases, module architecture, coding standards, and lessons learned from the implementation.
This article explains why and when to break a monolithic application into micro‑services, outlines practical splitting strategies, essential design principles, and the risks involved, while providing concrete guidelines for teams, business scale, and technical readiness.
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.
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.
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.
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.
This article reviews the core concepts of Domain‑Driven Design and layered architecture, compares four‑layer, five‑layer (DCI), six‑layer, and hexagonal (ports‑and‑adapters) patterns, and provides practical guidance for selecting the most suitable architecture for microservice 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.
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.
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.
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.
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.
The article explains the concepts, rules, and evolution of layered architecture—including strict layering, relaxed layering, and inheritance‑based layering—while illustrating practical implementations with Java code and discussing how front‑end separation and DDD influence architectural decisions.
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.
This article explains how Domain‑Driven Design (DDD) helps large‑scale systems separate business and technical complexity, using strategic and tactical patterns such as bounded contexts, layered, hexagonal and clean architectures, CQRS, and context mapping to enable rapid response to changing requirements.
The article explains how a universal language and bounded context in Domain‑Driven Design reduce communication loss, guide consistent terminology, and serve as the primary basis for defining microservice boundaries, illustrating concepts with examples from e‑commerce and insurance domains.
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.
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.
The article explains the historical background of DDD, why it resurfaced with the rise of microservices, how it helps define business boundaries, and outlines the strategic and tactical steps for applying DDD to design clear, high‑cohesion, low‑coupling microservice architectures.
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.
This article shares a comprehensive PPT from the 2018 Domain-Driven Design China Summit, offering valuable insights and practical guidance for mastering DDD, a pivotal approach to software architecture and domain modeling in modern development.
The article explains how the evolution from monolithic to microservice architectures created a need for clear business boundaries, why DDD gained traction after the microservice boom, and outlines the strategic and tactical steps to apply DDD for effective service decomposition.
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.
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.
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.
This article explains the concept of domain models, why they are crucial business assets, how to create and use them with UML diagrams and simple examples, highlights common misconceptions, and shows how explicit modeling improves communication, code readability, and software adaptability.
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.
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.
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.
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.
This article explains how to apply layered architecture and Domain‑Driven Design (DDD) to a Java‑based fresh‑food e‑commerce microservice system, outlining a five‑layer stack, domain partitioning, practical guidelines, and common pitfalls to help teams build maintainable, scalable back‑ends.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.