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.
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.
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.
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.
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.
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.
This article describes Qunar's comprehensive API standardization effort, detailing the evolution of their API tools, the motivations behind adopting DDD and API governance, the theoretical foundations, the QDoc annotation framework, implementation steps, challenges faced, achieved outcomes, and future plans for continuous improvement.
This article describes how a hotel pricing platform was refactored using Domain-Driven Design, detailing the strategic, tactical, and implementation phases that clarified domain boundaries, introduced a layered architecture, standardized processes, and delivered faster development, better maintainability, and improved operational visibility.
This article presents a practical approach to applying layered architecture and Domain‑Driven Design (DDD) to a Java‑based fresh‑food e‑commerce microservice system, outlining five layers, their responsibilities, design principles, domain partitioning tips, and common pitfalls to help engineers build maintainable, scalable back‑ends.
This article explains a practical approach to applying layered architecture and Domain‑Driven Design (DDD) to a Java microservice‑based fresh‑food e‑commerce platform, outlining five architectural layers, domain service partitioning, common pitfalls, and guidance for building maintainable, high‑cohesion services.
This article explains how the Tongtian Tower platform adopted Domain‑Driven Design to separate business and technical complexity, improve scalability, and enable rapid response to changing requirements through strategic and tactical design, bounded contexts, hexagonal and clean architectures, and related patterns such as CQRS and microservices.
This article describes the design, domain‑driven architecture, probability algorithms, extensibility mechanisms, concurrency controls, and management UI of a reusable lottery platform that supports high‑traffic promotional activities while ensuring configurability, anti‑cheat measures, and reliable data consistency.
This article explains the principles, types, and layer responsibilities of DDD layered architecture, compares it with traditional four‑layer and three‑layer designs, and shows how microservices can evolve by reorganizing aggregates and applying dependency inversion across UI, application, domain, and infrastructure layers.
This article explains DDD aggregates, aggregate roots, entities and value objects, shows how to model them with event‑storming, illustrates e‑commerce and insurance examples, discusses design principles such as small aggregates, consistency boundaries, and cross‑aggregate communication.
This article explains why value objects are essential in Domain‑Driven Design, outlines their defining characteristics, shows practical modeling examples, compares different implementation forms, and demonstrates how they can simplify database design while highlighting their advantages and pitfalls.
This article explains why entities are essential in domain‑driven design, how to define unique identifiers, ensure their stability, model entities in various states, and implement robust constructors with Java code examples and practical guidelines.
This article explains how defining bounded contexts and establishing a ubiquitous language during event‑storming sessions ensures clear, consistent terminology that maps directly to domain objects and code, guiding accurate microservice design and implementation.
This article explains how to treat Domain‑Driven Design as code by leveraging ContextMapper's DSL to model strategic and tactical aspects, define subdomains, bounded contexts, context maps, and generate consistent documentation and code artifacts for microservice architectures.
The article explains how Domain‑Driven Design (DDD) complements microservice architecture by addressing functional partitioning, clarifying bounded contexts, and guiding service decomposition, while also highlighting microservices' shortcomings in handling requirement changes and offering practical guidelines for effective system splitting.
This article recounts SuNing’s step‑by‑step journey of designing and implementing a supply‑chain data middle platform, outlining its business rationale, DDD‑based domain modeling, layered system architecture, and practical deployment insights that illustrate how a tailored big‑data solution can enhance data services and governance.
EventStorming is a rapid, lightweight collaborative modeling practice that combines Gamestorming and Domain‑Driven Design to accelerate team learning and build shared domain models across technical and business contexts.
This tutorial walks through a complete Golang implementation of a food‑recommendation API using Domain‑Driven Design (DDD), covering the four DDD layers, entity and repository definitions, persistence setup with Gorm, application services, HTTP interfaces, middleware, and how to run the service.
This article reflects on the redesign of a high‑traffic transaction system, discussing the decision‑making process, programming paradigms, SOLID principles, domain‑driven design, component decomposition, and the evolution from simple state machines to flexible, maintainable backend architectures.
In this article, Meituan‑Dianping expert Mu Zongyan’s GIAC conference talk highlights that while Domain‑Driven Design has become popular with microservices, its true power lies in strategic design rather than rigid tactical patterns, urging architects to focus on broader business contexts.
This article explains the core concepts of Domain‑Driven Design, including model‑driven design, ubiquitous language, bounded contexts, layered and hexagonal architectures, and key building blocks such as entities, value objects, aggregates, repositories, factories, and services, to help developers build business‑centric enterprise applications.
This article walks through the complete design of an e‑commerce microservice architecture, covering module identification, domain‑driven design, service splitting, technology stack choices between Dubbo and Spring Cloud, distributed transaction patterns, resilience with Hystrix, centralized configuration, and observability with SkyWalking.
This article examines the challenges of traditional retail accounting, introduces the concept of a financial middle platform, outlines its business and application architecture using the C4 model, and provides practical guidance for evolving the design into a micro‑service ecosystem while balancing complexity and performance.
This article details how applying Domain‑Driven Design to a complex e‑commerce discount system clarified business logic, improved flexibility, and guided a step‑by‑step architectural overhaul from a monolithic model to a layered, domain‑centric solution with tactical and strategic design considerations.
This article walks through building an e‑commerce platform using microservices, covering module decomposition, domain‑driven design, service splitting, technology stack choices, distributed transaction strategies, circuit‑breaker patterns, centralized configuration, monitoring, and capacity planning to guide developers from concept to deployment.
This article introduces Domain‑Driven Design, explains why traditional MVC‑based CRUD approaches lead to heavy, hard‑to‑maintain services, and shows how DDD concepts such as aggregates, bounded contexts, event sourcing and CQRS can clarify business logic, improve micro‑service boundaries, and reduce system complexity.
By applying micro‑frontend principles and DDD‑based microservice design, the article explains how insurance companies can build modular, reusable front‑end components that integrate with backend middle‑platform services, thereby lowering integration complexity, improving scalability, and enabling unified, cross‑product order sales across multiple channels.
This article explains what microservices truly are, debunks common misconceptions, outlines their key characteristics, discusses pitfalls such as over‑splitting into tiny monoliths, and highlights the importance of automated operations and DevOps practices for successful implementation.
EventStorming is a rapid, lightweight group modeling practice that accelerates shared domain understanding and domain‑driven design by using domain events, commands, bounded contexts, and collaborative workshops, making it applicable to any complex technical or business domain.
This tutorial walks through persisting Domain‑Driven Design aggregates by first explaining aggregates and aggregate roots, then showing Java class examples, followed by practical JPA/Hibernate integration challenges and a complete MongoDB document‑store solution, highlighting trade‑offs and best practices.
An extensive overview of JD.com's microservice component platform explains its underlying architecture, communication technologies, service mesh (ContainerMesh), design tools based on DDD, service evaluation, migration challenges, and the platform's evolution toward a cloud‑native, self‑evolving ecosystem supporting distributed tracing, API gateways, and plugin‑based development.
The article details how JD.com’s 7Fresh retail platform was built in just two and a half months by applying strategic DDD, virtual organization structures, extensive component reuse, and cross‑team collaboration to integrate over 60 systems and dozens of devices for both online and offline operations.
This article explains why domain modeling is crucial for managing complex business logic, compares transaction scripts with domain models using a bank transfer example, outlines the benefits of object‑oriented design, and provides practical steps and best practices for building, evolving, and visualizing domain models.
This article walks through a practical transformation of an old payment architecture into a high‑availability microservice ecosystem, covering SOA vs. microservices, DDD‑guided domain boundaries, Dubbo‑based implementation, operational challenges, continuous integration testing, and future plans for multi‑active data centers.
The article demonstrates how applying Domain‑Driven Design to a lottery platform’s microservices—by defining bounded contexts such as lottery and risk control, modeling aggregates like DrawLottery and AwardPool, using domain services and anti‑corruption layers, and enforcing high cohesion and low coupling—solves over‑coupling and anemic domain model challenges while tightly aligning the system with business logic.
Frank, a senior technical expert at Alibaba International, shares how his team tackled the growing complexity of their legacy CRM system by redesigning the architecture with extensible extension points, metadata, CQRS, DDD, SOLID principles, and disciplined layering to achieve better scalability, maintainability, and code readability.
The article explains how traditional microservice architectures evolve into event‑driven reactive microsystems by adopting events‑first DDD, reactive design, and event‑based persistence, highlighting the role of the Actor model, asynchronous non‑blocking communication, event sourcing, and saga‑based distributed transaction handling.
The article records a Meituan‑Dianping Q&A on Domain‑Driven Design, where engineers discuss using domain events with transactions, designing RPC interfaces, separating domain and application layers, handling cross‑aggregate operations, and defining bounded contexts, illustrating how DDD guides microservice architecture and business modeling.
This article explains the fundamental ideas of Domain‑Driven Design, showing how to build expressive domain models, use a ubiquitous language, map bounded contexts, apply strategic and tactical patterns, and implement the concepts with C# code, UML sketches, and architectural guidelines.
