This article explains the 4A enterprise architecture model, compares it with TOGAF and Huawei’s “One Body Four Faces” framework, outlines the four architectural layers, and shows how Domain‑Driven Design can be mapped onto each layer with concrete examples and diagrams.
This article explains Domain‑Driven Design (DDD) from its origins to practical modeling, compares it with MVC, outlines business and personal benefits, discusses drawbacks, details strategic and tactical concepts, and walks through a real‑world VOC product example using event‑storming and four‑color modeling.
This article walks through the application of Domain-Driven Design (DDD) in a B‑side marketing platform, detailing how strategic design defines use cases and unified language, tactical design maps concepts to object models, and code architecture organizes implementations, illustrated with concrete examples, diagrams, and practical guidelines.
This article details Ctrip's account system evolution, covering its transition from monolithic to domain‑driven microservices, middle‑platform consolidation, and multi‑region deployment, including design goals, read/write comparison processes, configuration‑driven capabilities, and routing strategies to improve scalability, reliability, and operational efficiency.
This article shares hands‑on experience of applying Domain‑Driven Design in real projects, detailing a typical four‑layer architecture (domain, infrastructure, application, adapter), code examples, packaging guidelines, and practical tips for clean, maintainable backend systems.
Domain‑Driven Design aligns software architecture with business needs by establishing a shared language, clear bounded contexts, and strategic‑tactical patterns—entities, value objects, aggregates, services, and events—while using techniques such as Event Storming and Four‑Color Modeling to visualize domains, guide micro‑service boundaries, and produce maintainable, adaptable systems.
The article details a SaaS company's two‑month development of an AI‑powered skin‑analysis solution, illustrating how DDD’s four‑color modeling split health services into aggregates, integrated Face++ APIs, and delivered a 30‑second, 30‑dimension skin report that attracted over 80 000 users and 9 000 orders.
The article recounts Meituan Dianping’s transaction system evolution—from a simple MVC design to microservices and a plug‑in platform—illustrating how domain‑driven design’s ubiquitous language, bounded contexts, and strategic modeling guided the separation of core, supporting, and generic domains and enabled scalable, maintainable architecture.
This article explains Domain‑Driven Design's Domain Primitive concept from a front‑end perspective, compares it with VO/DTO/PO, outlines its principles, provides concrete TypeScript examples, and shows how applying DP can improve validation, encapsulation, and testability in real‑world projects.
The article examines the difficulties of applying Domain-Driven Design to a cloud‑disk file‑upload scenario, demonstrates how to simplify the code by extracting business models, introducing factories and repositories, and explains how these patterns clarify the separation between business and technical concerns.
This article explains how applying CQRS and layered splitting—separating commands and queries across service, model, repository, and data layers—can dramatically lower system complexity, improve performance, and resolve common conflicts in high‑traffic backend applications.
This article explores the fundamentals of Domain‑Driven Design, its challenges, practical steps for applying DDD concepts such as value objects, repository patterns, hexagonal architecture, and domain layer design, and shares concrete refactoring experiences to build more maintainable, extensible, and testable systems.
Domain-Driven Design (DDD) is a software design methodology that simplifies complex business domains by defining clear boundaries, layers, and core concepts such as aggregates, entities, value objects, and bounded contexts, helping teams achieve better business understanding, modularity, maintainability, and efficient architecture.
This article explains Domain-Driven Design (DDD), its purpose, core concepts, layered architecture, and practical application scenarios, showing how DDD reduces business complexity, improves extensibility, and promotes reusable, maintainable code in backend systems.
This article walks through the practical application of Domain‑Driven Design to a large‑scale pricing system, detailing business understanding, strategic and tactical design, context integration, layered architecture, and concrete Java implementations that illustrate how DDD improves modularity, testability, and maintainability.
This article explains how to start a new project using Domain-Driven Design, covering IAAS/PAAS/SAAS terminology, architecture evolution, bounded contexts, the four DDD boundaries, clean layered, hexagonal, and onion architectures, and their impact on microservice design.
This article explains how to model and implement a marketing reverse domain that handles coupon and asset recovery during refunds, using domain‑driven design, rule engines, and service layers, complete with state‑machine diagrams, code snippets, and practical mapping configurations.
This article explains how Domain‑Driven Design was applied to the Tencent Video “Together Watch” system, presenting a step‑by‑step domain modeling process, mapping to a layered micro‑service architecture, and a quantitative evaluation of the refactoring’s impact on modularity, performance, code size, and operational costs.
This article explains what a finite state machine (FSM) is, illustrates it with a car transmission example, outlines its components and diagramming, discusses its technical pros and cons, explores business benefits, and examines how state machines relate to domain‑driven design.
Understanding an application's architecture—defining clear module and package hierarchies, adopting layered patterns like Hexagonal or Clean Architecture, and applying principles such as Dependency Inversion and CQRS—transforms chaotic codebases into maintainable, testable systems that reduce onboarding time and simplify future development.
This article explains how Domain‑Driven Design (DDD) combined with Spring Data JPA enables clean, object‑oriented modeling of order workflows, introduces the Repository pattern for persistence, and demonstrates the full lifecycle—from creation to address modification and payment—through concise Java code and SQL examples.
This article explores Domain‑Driven Design fundamentals, illustrating how to expose hidden concepts, adopt hexagonal architecture, and implement repository patterns to achieve high scalability, maintainability, and testability in complex software systems, while addressing common pitfalls like the anemic model.
The article details Bilibili’s migration of its legacy PHP live‑broadcast service to Go microservices using Domain‑Driven Design and Hexagonal architecture, describing event‑storming, six‑layer tactical design, TDD, traffic‑mirroring migration, and resulting higher reliability, lower latency, and improved maintainability.
This article explores simple, complex, and composite value objects in PHP, providing guidelines for their design, validation, immutability, string representation, equality checks, while also discussing alternative error handling approaches such as Either types and union types.
This article explores how to build a robust engineering architecture by prioritizing product value, defining clear layered and DDD structures, selecting appropriate technologies, and establishing standards for exception, logging, monitoring, and team collaboration to achieve scalability, maintainability, reliability, security, and high performance.
Domain-Driven Design (DDD) is a methodology for tackling software complexity by aligning business, system, and organizational structures through strategic and tactical modeling, using techniques such as metaphors, layering, refinement, abstraction, bounded contexts, and a ubiquitous language, illustrated with real-world Tencent video system case studies.
This article explains how Domain-Driven Design (DDD) rose to prominence by addressing the difficulty of defining business boundaries in microservice architectures, outlines the evolution of software architectures, describes DDD's strategic and tactical design concepts, and provides practical steps for applying DDD to create well‑bounded, high‑cohesion services.
This article explains Domain-Driven Design as a methodological approach for handling software complexity by aligning business, system, and organizational structures through modeling, detailing its core concepts, goals, key methods, and real‑world case studies from large‑scale systems.
This article chronicles the year‑long evolution of the voice‑chat room system, detailing how product‑driven requirements forced successive redesigns of both the live‑streaming and RTC subsystems, the introduction of session‑and‑channel abstractions, migration of mic‑seat management to the backend, and the implementation of monitoring, testing, and deployment practices that keep the architecture stable and extensible.
Domain‑Driven Design is a methodological approach that refactors large, complex systems by aligning business language with architecture through metaphors, layering, refinement and abstraction, organizing code into high‑cohesion, low‑coupling bounded contexts, and applying strategic and tactical modeling—illustrated by Tencent Video case studies and contrasting lightweight versus rigorous practice styles.
The article demonstrates how combining Domain‑Driven Design with architecture mapping can transform a complex video‑membership platform by modeling domains, refactoring monolithic components into a clean micro‑service architecture, and quantitatively evaluating the resulting reductions in code size, latency, cost, and improved modularity.
EventStorming is a rapid, lightweight group modeling technique that accelerates domain understanding by having cross‑functional teams collaboratively identify domain events, commands, aggregates, and bounded contexts, enabling faster, shared domain models and reducing reliance on individual DDD expertise.
This article explains why software architecture matters, defines the essence of Clean Architecture, compares it with Hexagonal and DDD layered models, and walks through a practical, step‑by‑step process—from business analysis and domain modeling to layer implementation and code examples—showing how to reduce complexity and maintenance cost.
The article systematically examines Domain‑Driven Design through four discourses—Structure, Process, Language, and Modeling—while contrasting the practical “folk” school with the academic school, linking philosophical ideas, software‑complexity theory, strategic and tactical design, refactoring, agile practices, ubiquitous language, and its parallels to UML/SysML, arguing DDD repackages existing engineering concepts rather than inventing new ones.
This presentation details Qunar.com's journey from a monolithic system to a service‑oriented, platform‑based architecture, emphasizing domain‑driven design principles, architectural evolution paths, reconstruction strategies, the adoption of the COLA framework, and the resulting improvements in organization and development efficiency.
The article explains why solid software architecture matters, introduces Robert C. Martin’s Clean Architecture and its framework‑, UI‑, database‑, and service‑independent principles, compares it with Hexagonal and DDD layered styles, details strategic and tactical phases for front‑end MVVM projects, provides layered code samples, and weighs its benefits against the initial overhead, urging teams to choose the approach that fits their project’s complexity and lifespan.
This free, four‑part kata lets participants practice architecture and domain‑driven design by creating a business model for a fictional online car dealership, exploring domain boundaries with event storming, aligning domains to strategy, and modeling message flows using commands, events, and queries.
This article recounts a 2009 mob programming session in which the GoCD team refactored a module by introducing a missing domain object, illustrating the benefits of whole‑team collaboration, the prerequisites of a strong development environment and automated tests, and detailing the step‑by‑step code transformations.
This article explains the concepts, strategic and tactical designs, layered architecture, key objects, aggregates, bounded contexts, and implementation steps of Domain-Driven Design (DDD) and how it guides the modeling and decomposition of microservices and middle‑platform systems.
This article explores the challenges of retail product systems and presents a domain‑driven design approach, detailing the “Dao” (strategic planning) and “Shu” (technical tactics) of architecture, the divide‑and‑conquer plus orchestration strategy, abstract domain models, layered DDD structure, and data flow management to achieve a flexible, resilient solution.
This article explains how to apply Clean Architecture principles to a frontend React/TypeScript project, covering the three‑layer structure, dependency rules, domain modeling, use‑case design, adapter implementation, code organization, trade‑offs, and practical tips for building a cookie‑store example.
This comprehensive guide explains software methods—including business modeling, requirement analysis, domain modeling, UML relationships, and design principles—illustrating how systematic modeling improves product quality, reduces costs, and enhances engineers' professional growth.
The Gaode Business Framework (GBF) is a lightweight, domain‑driven solution that unifies disparate industry portals by partitioning stable domains, standardizing interfaces, and providing customizable implementations, thereby eliminating duplicated glue code, improving design quality, reducing development costs, and enhancing stability and cross‑team collaboration.
This article explains the core DDD concepts of aggregate roots and domain events, illustrates them through a simplified e‑commerce scenario, and provides complete Java code examples for entities, value objects, events, and aggregate services to help developers apply DDD in backend systems.
This article explains the core concepts of enterprise architecture, defines both enterprise and architecture, outlines major frameworks such as Zachman, TOGAF, DoDAF and FEA, distinguishes business and IT architecture, and details the components, models, and practical integration of business architecture with value streams, capabilities, information, organization, products, stakeholders, policies, and metrics.
This article provides a systematic overview of Domain-Driven Design, explaining its origins, core concepts, modeling approaches, strategic and tactical design steps, service decomposition principles, and practical examples to help developers understand and apply DDD in complex software projects.
This article explains how Gaode's Information Business team tackled fragmented portal implementations across multiple industries by adopting the Gaode Business Framework (GBF) and domain‑driven design, achieving unified architecture, reduced duplication, improved reusability, and enhanced system stability and maintainability.
The article describes how Volcano Engine's DataTester team refactored the advertising AB testing platform by splitting services, redesigning the data model with MySQL and ClickHouse, introducing DAG‑based scheduling and a time‑wheel algorithm, and applying domain‑driven design and rigorous unit testing to improve stability, scalability, and maintainability.
This article explains how business complexity arises from scale and domain logic, and demonstrates how Domain‑Driven Design—through subdomains, bounded contexts, orthogonal business‑technology separation, consistent code models, and strategic‑tactical design—helps manage and reduce that complexity in software systems.
This article explains clean architecture concepts—domain, use case, and application layers—and demonstrates how to apply them in a frontend React/TypeScript project, covering design principles, layer responsibilities, dependency rules, advantages, costs, and concrete code examples for a cookie‑shop example.
This article analyzes the evolving landscape of large‑model applications, detailing prompt engineering, engineering challenges, AI‑engineer roles, domain‑driven design, and agent frameworks, while offering practical guidance and references for building production‑grade LLM‑driven systems.
This article explains how to start a new project using Domain‑Driven Design, covering key terminology, architecture evolution, bounded contexts, the four DDD boundaries, and common architectural styles such as clean layered, hexagonal, and onion architectures.
This article explains the core concepts of Domain‑Driven Design, distinguishes its strategic and tactical patterns, and shows how Redux implements similar ideas such as queries, commands, domain events, and aggregates, while also discussing event sourcing, CQRS, and code examples for decoupling.
This article explains how to apply Domain-Driven Design (DDD) from project inception, covering key terminology, architectural evolution, bounded contexts, the four DDD boundaries, and various layered architectures such as clean, hexagonal, and onion models to achieve modular, maintainable systems.
This article starts from a conventional three‑layer architecture, refines it into a domain‑driven design (DDD) application structure, demonstrates the evolution through five concrete steps, and shows how to package the final architecture as a reusable Maven Archetype with detailed installation and usage instructions.
This article describes a practical approach to automatically extract and visualize business system knowledge from code by abstracting workflow control logic into a generalized design pattern using the FSM‑X state‑machine framework, discussing its background, methodology, implementation details, and current limitations.
The article explains what constitutes a complex system, defines software architecture, outlines its essential elements, categorizes various architecture types, discusses key factors such as functional and non‑functional requirements, and presents design principles and typical solutions for building robust, scalable systems.
This article explains what complex systems and software architecture are, outlines various architectural categories, discusses essential functional and non‑functional requirements, and presents design principles and typical solutions such as domain‑driven design, microservices, cloud‑native, DevOps, and big‑data architectures for building stable, scalable, and maintainable systems.
This article explains what complex systems are, defines software architecture, explores its essence and classifications, outlines key architectural factors, and presents design principles and typical solutions such as domain‑driven design, microservices, cloud‑native, and big‑data architectures.
This article explains how Domain‑Driven Design (DDD) can be applied to a complex pricing system, covering business understanding, strategic and tactical design, context integration, layered architecture, code organization, and concrete Java examples that illustrate evaluation and pricing algorithms.
This article, the final installment of a DDD series, walks through a practical implementation of Domain‑Driven Design in Go using Kitex and Thrift, covering bounded contexts, layered architecture, domain modeling, persistence, factories, domain services, and cross‑cutting concerns in a fictional e‑commerce system.
This article walks through the essential concepts of Domain‑Driven Design, detailing a layered architecture, practical code organization, integration techniques such as Open Host Service and Anticorruption Layers, and a concise introduction to CQRS for handling complex queries efficiently.
This article explains the complete Domain‑Driven Design (DDD) workflow, covering the problem‑space analysis, bounded‑context mapping, layered architecture, and the three modeling phases—analysis, design, and implementation—while emphasizing unified language, core, generic, and supporting sub‑domains.
This article explores how to break down the complex marketing domain into modular, atomic components—limits, rules, benefits, and feedback—using Node.js, demonstrates a flexible factory pattern for assembling activities, and provides practical advice for refactoring and product design in real‑world projects.
The article explains Domain‑Driven Design as a method for managing software complexity, outlines its meta‑models and limitations, and demonstrates a full problem‑domain analysis for Bilibili’s OGV business—including stakeholder value‑demand analysis, process and use‑case modeling, scenario definition, ubiquitous language creation, and sub‑domain classification—while noting that implementation details will be covered later.
This article explains why architecture design, especially Domain‑Driven Design, is essential for controlling the complexity, cost, and scalability of microservice systems, detailing common misconceptions, sources of complexity, and concrete steps to define clear domain and service boundaries.
This article explains what a complex system is, defines software architecture, explores its essence and classifications, and outlines the key factors, analysis methods, design principles, and typical solution patterns such as DDD, micro‑services, cloud‑native, DevOps, and big‑data architectures.
This article explains how to start a new project using Domain‑Driven Design, covering terminology, architectural evolution across SaaS, PaaS, IaaS, bounded‑context division, the four DDD boundaries, clean layered, hexagonal and onion architectures, and concludes with practical guidance.
The article explains the COLA (Clean Object‑Oriented and Layered Architecture) framework, its layered design—including Adapter, Client, App, Domain, and Infrastructure layers—provides Maven module examples and Java code snippets, and discusses its benefits and limitations for maintaining fast‑evolving business codebases.
This article explains what Domain‑Driven Design (DDD) is, why it targets business‑logic complexity, examines its suitability for front‑end development, and offers practical strategies to reduce front‑end technical and business complexity by applying DDD principles.
This article explains why and how to decompose large or legacy applications into microservices using business‑capability and sub‑domain (DDD) approaches, outlines their benefits, discusses common challenges such as latency and data consistency, and introduces the Strangler pattern for gradual migration.
This article explains the fundamentals of Domain‑Driven Design, covering its core ideas such as model‑driven design, ubiquitous language, bounded contexts, layered and hexagonal architectures, and key building blocks like entities, value objects, aggregates, repositories, factories, and services, with practical examples and diagrams.
This article explains the fundamentals of Domain‑Driven Design, distinguishes strategic from tactical design, outlines core DDD elements such as domains, aggregates and bounded contexts, and demonstrates how four‑color modeling can be applied to real‑world e‑commerce microservice architectures.
This article walks through the author’s two‑year experience applying Domain‑Driven Design to payment, settlement and fund services, explains strategic vs tactical design, compares classic DDD layers, Clean, Hexagonal and Diamond architectures, details module organization, CQRS, and shares practical pros, cons and implementation tips.
This article explains how Domain‑Driven Design can guide the splitting of monolithic applications into well‑structured microservices by introducing DDD fundamentals, strategic domain modeling, tactical design patterns, and a concrete Go code example that demonstrates a four‑layer architecture.
The article explains the three core principles of Hexagonal (Ports‑and‑Adapters) Architecture, illustrates how to separate application, domain, and infrastructure code with concrete C# examples, and shows how this separation improves testability, dependency inversion, and modular design.
This article explains how to apply Domain‑Driven Design (DDD) to a brand‑new project, covering essential terminology, architecture evolution across SaaS, PaaS, IaaS, bounded‑context segmentation, the four DDD boundaries, clean layered, hexagonal, and onion architectures, and provides practical guidance for effective system design.
This article explains the core concepts of Domain-Driven Design, why it is needed to address typical development problems, and how its strategic and tactical practices—such as bounded contexts, ubiquitous language, aggregates, and domain events—help teams build clearer, more maintainable software systems.
This article explains how to start a new project using Domain‑Driven Design, covering key terminology, the evolution of architecture layers, bounded context concepts, the four DDD boundaries, and various architectural styles such as clean layered, hexagonal, and onion architectures.
This article explains how to start a new project using Domain‑Driven Design, covering terminology, the evolution from SaaS to IaaS, bounded‑context concepts and division rules, the four DDD boundaries, and how clean, hexagonal, and onion architectures realize these principles for scalable backend systems.
This article explains how to start a new project using Domain‑Driven Design, covering key terminology, architecture evolution from monolith to microservices, bounded context division, the four DDD boundaries, clean layered, hexagonal and onion architectures, and practical design guidelines for backend systems.
This article curates the ten most-read technical posts from NetEase Yanxuan in 2022, covering DDD adoption, reverse transaction systems, availability metrics, documentation practices, inventory locking, performance optimization, stability governance, H5 containerization, 2B architecture, and the evolution of the Yanxuan app’s engineering architecture.
This article describes how a data‑architecture team tackled the complexity of a large‑scale telephone‑robot system by adopting Domain‑Driven Design, detailing the challenges faced, the reasons for choosing DDD, the concrete rollout steps, and the resulting improvements in architecture, communication, documentation, and code quality.
This article presents a practical methodology for handling complex business scenarios by combining top‑down process decomposition with bottom‑up domain modeling, illustrating the approach with a retail product onboarding case, code examples, and guidance on capability sinking and model‑driven design.
This article explains how a WeChat team used Domain‑Driven Design to improve the maintainability, scalability, and stability of a fast‑paced, multi‑team e‑commerce project, covering strategic and tactical modeling, layered architecture, subdomains, bounded contexts, anti‑corruption layers, domain events, aggregates, repositories, and a practical code scaffold with C++ examples.
The article explains how a WeChat e‑commerce team adopted Domain‑Driven Design, reorganizing a fast‑paced, multi‑team project into a four‑layer onion architecture with strategic sub‑domains, bounded contexts, anti‑corruption layers, domain events, aggregates, repositories and services, to achieve maintainability, extensibility, cohesion and loose coupling.
This article explains a layered microservice architecture, detailing the responsibilities of Facade, Application, Domain, and Infrastructure services, the interaction patterns within and between services, strict versus loose layering, and the roles of various data objects such as PO, DO, DTO, and VO.
Amid sweeping layoffs in Silicon Valley and China, developers must shift from generic coding to specialized expertise by building irreplaceable core competencies, understanding true business knowledge, and applying domain‑driven design to stay valuable in a maturing market.
This article explains how Domain‑Driven Design (DDD) guides the strategic and tactical decomposition of monolithic applications into well‑bounded microservices, outlines its benefits such as a unified language and clearer domain boundaries, and provides concrete code examples from a membership‑center service.
This article examines the technical challenges of B‑end contract advertising systems, tracing the evolution of Baidu's ad‑placement platform from a monolithic architecture through multiple business stages to a domain‑driven microservices design, and discusses service governance, observability, anti‑corruption, and iterative development practices.
This article explains how to build a modular backend service in Java using domain‑driven design, configurable modules, dynamic proxies, cache adapters, lambda‑based query conditions, and Spring‑based conditional bean loading to enable flexible extensions without altering existing code.
The article examines Baidu's Contract Advertising Platform, detailing its shift from a monolithic, siloed design to a DDD‑driven microservices architecture using COLA, CQRS, and layered governance, and shares best practices for handling complex B2B advertising scenarios, service iteration, and evolving business needs.
This article explores the challenges of implementing Repository in Domain‑Driven Design, introduces the innovative “Repository Entity Transfer” concept, compares in‑memory and relational implementations, discusses concurrency, specifications, and architectural patterns, and provides practical code examples to help developers build cleaner, model‑centric back‑end systems.
Onion Architecture, a DDD‑aligned design pattern, structures applications into concentric layers centered on the domain model, promoting loose coupling, testability, and technology‑agnostic core logic, while detailing principles, layer responsibilities, testing strategies, microservice applicability, modular packaging, and practical implementation considerations.
This article walks through the complete process of designing a budget‑control platform using Domain‑Driven Design, covering background analysis, strategic and tactical design, domain modeling, service decomposition, interface definition, and technical implementation to illustrate how to build a cohesive, scalable backend service.
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.
This article explores how structured domain model metadata, derived from domain‑driven design principles, can standardize business component descriptions, enable visual UML modeling, support low‑code and no‑code generation, and ultimately reduce development costs while accelerating delivery of enterprise support systems.
This article explains why Domain‑Driven Design is needed, critiques traditional development workflows that produce opaque code, and presents various modeling and aggregation strategies—including code examples—to involve non‑developers and bridge the gap between business experts and developers.
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.
