The author recounts a three‑year journey of scaling a Python‑based HR SaaS backend from a simple Django MVC prototype to a microservice architecture with domain‑driven design, detailing each architectural stage, the challenges faced, and the concrete optimizations applied.
The author recounts a four‑stage evolution of a Python‑based SaaS backend—from a simple Django MVC prototype through service splitting, microservice adoption with Kong and custom RPC, to an exploratory domain‑driven design—highlighting practical problems, optimizations, and architectural trade‑offs.
This article presents a practical methodology for writing clean, maintainable code for complex business scenarios, using structured top‑down process decomposition combined with bottom‑up object modeling, illustrated with a retail product‑on‑sale case, code samples, and guidance on tool usage, domain modeling, and capability sinking.
This comprehensive guide walks you through the fundamentals of system design, covering core concepts, analytical thinking, modeling techniques, architecture classification, design tools, and best‑practice principles to help you build robust, scalable software systems.
In this interview, senior ZTE architect Zhang Xiaolong explains why development teams should adopt Domain‑Driven Design, outlines key practices such as a unified language, layered architecture, and domain events, and discusses common obstacles—including limited case studies and tooling gaps—and offers practical solutions to successfully implement DDD in complex, high‑performance telecom software.
This article explains the business challenges of handling marketing assets during refunds, defines asset types and trigger conditions, and details a domain‑driven backend architecture—including entities, value objects, aggregates, services, and model‑mapping configurations—to implement a configurable reverse‑operation system.
iQIYI’s contract platform replaced a cumbersome Activiti workflow with a lightweight combination of Axon Framework and Spring StateMachine, leveraging DDD, CQRS, and event sourcing to achieve clear layered architecture, traceable events, and flexible state transitions, while confronting distributed‑transaction sagas, batch limits, and integration complexities, and planning future Axon Server adoption.
This article explains the fundamentals of data modeling for front‑end development, covering its three core elements, integrity constraints, domain‑driven design, layered architecture, and practical guidelines for building clean, maintainable front‑end data models.
This article explains how business architecture controls system complexity through layered structures and domain‑driven design, compares traditional three‑tier and microservice architectures, highlights common pitfalls, and offers a lightweight domain‑centric approach for scalable, maintainable backend systems.
The article explains how deep integration of technology and business drives enterprise innovation by mastering product‑market fit, outlines a five‑step PMF process, and details how Domain‑Driven Design can be used for systematic domain modeling to build sustainable competitive advantage.
This article explains the concepts of Domain‑Driven Design, why it has gained traction in China’s internet industry, and how Alibaba Entertainment applies strategic and tactical DDD practices—such as model annotation, health‑check, and hexagonal architecture—to improve scalability, readability, and maintainability of its micro‑service systems.
This weekly tech roundup explains how JavaScript sandboxes isolate code, details a low‑cost AST‑based code‑scanning approach, compares Vue, React and Angular, and shows how domain‑driven design and CSS variables can streamline modern front‑end development.
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 article explores the communication gaps that hinder software projects, introduces Event Storming as a visual, collaborative workshop technique, walks through its syntax and practical coupon‑distribution example, connects the outcomes to Domain‑Driven Design, and shows how the method improves alignment between product, business, and engineering teams.
This article walks through a complete Go implementation of a food recommendation API using Domain-Driven Design, covering project setup, layer separation, entity and repository definitions, infrastructure configuration, application services, HTTP interfaces, authentication, and how to run the application.
The article explains DDD’s core building blocks—entities identified by persistent IDs, immutable value objects, and aggregates that group related objects under a single root—using a car‑model case study to show how roots enforce invariants, how factories, repositories and lazy‑loaded references fit within a hexagonal architecture, and why these practices improve modular, maintainable software.
Beike’s real‑estate platform transitioned from a monolithic application to a service‑oriented, domain‑driven mid‑platform, detailing the architectural analysis, phased evolution, componentization, data services, and operational insights that enabled scalable, reusable business capabilities across multiple city‑level services.
The article, the second in a DDD practice series, shows how immutable domain events can capture business milestones and be stored and published, introduces Saga—both choreography and orchestration—to manage distributed transactions with compensations, and explains how CQRS separates read and write models, illustrating each concept with Java code while highlighting the resulting decoupling, scalability, and modeling clarity alongside added complexity and storage challenges.
The Meituan Takeaway Marketing team shows how combining domain‑driven design with classic patterns such as Factory Method, Strategy, State and Responsibility Chain creates an extensible, maintainable reward system that adapts to rapidly changing business rules while keeping the domain model clean and SOLID‑compliant.
This article explores how Domain-Driven Design (DDD) can address the growing complexity of business and technical requirements in large-scale systems, detailing its strategic and tactical processes, layered and hexagonal architectures, and integration with microservices to achieve flexible, maintainable, and scalable software solutions.
Domain‑Driven Design, a mindset rather than a rigid methodology, clarifies business complexity through a central domain model, layered and hexagonal architectures, bounded contexts, and repository patterns—dispelling myths that it suits only large projects or adds excessive boiler‑plate, and showing practical Java implementation.
This article explains how the COLA 2.0 framework restructures Java backend applications by introducing a cleaner layered architecture, redefining components and modules, adding flexible extension points, and providing practical guidance for generating and using COLA‑based services.
This article outlines ten essential microservices best practices—from domain‑driven design and independent databases to async communication, observability, and organizational alignment—providing a comprehensive guide for building scalable, maintainable service‑oriented systems.
The article outlines Youzan's retail finance middle platform design, detailing the business background of complex SaaS retail, a structured analysis using layered business, application, data, and technology architectures, and a step‑by‑step implementation that emphasizes reusable domain capabilities and long‑term, standardized middle‑platform development.
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 presents a comprehensive, practice‑oriented overview of Domain‑Driven Design, covering its conceptual foundations, project‑level management, architectural layering, design patterns, implementation techniques with Java/Spring, testing, continuous integration, and deployment strategies for enterprise applications.
The article reflects on the parallels between urban planning and software design, critiques the pitfalls of unplanned legacy systems, outlines a typical three‑layer development workflow, and introduces domain‑driven design concepts as a disciplined approach to building maintainable backend architectures.
This article reflects on the redesign of a large‑scale transaction system, describing a decision‑making routine that starts from purpose and goals, discusses programming paradigms, SOLID principles, domain‑driven design, bounded contexts, component splitting, layering, and the trade‑offs of patterns such as State and CQRS to achieve a flexible, maintainable backend architecture.
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 presents a practical methodology for handling complex business logic by combining top‑down process decomposition with bottom‑up domain modeling, illustrating the approach with a detailed product‑on‑sale use case, code examples, and guidance on avoiding over‑reliance on tooling.
The article shows how to apply Domain‑Driven Design to construct an education‑sector lead management system, detailing the four‑layer architecture, a four‑color prototype analysis for requirements, core DDD concepts such as entities, value objects, aggregates and repositories, and a concrete implementation of domain models and services.
This article presents a practical methodology for handling complex business scenarios by combining top‑down process decomposition with bottom‑up domain modeling, illustrated through Alibaba's retail‑to‑store product onboarding case, complete with code examples and architectural guidance.
This article explores the principles of Clean Architecture, explains layered thinking and dependency rules, discusses how to apply them in real projects, and reflects on the broader meaning of software architecture, including domain‑driven design and practical advice for developers seeking to improve their design skills.
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 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.
Domain-Driven Design (DDD) focuses on modeling core business complexity by building a ubiquitous language, bounded contexts, and layered architectures, and the article explains key DDD patterns such as model‑driven design, aggregates, repositories, factories, services, and hexagonal architecture, illustrated with diagrams and Java code examples.
The article shows how to refactor a tangled Xianyu detail‑page built on legacy MVC by isolating each vertical business with the Strategy pattern, extracting shared services, packaging them as libraries or JARs, and then applying domain‑driven design to create a clean, layered, maintainable architecture.
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 article explains how software complexity arises from both business requirements and quality attributes, discusses the challenges of technical and business complexity, and demonstrates how Domain‑Driven Design—through layered and hexagonal architectures, bounded contexts, and micro‑service decomposition—helps isolate concerns and manage complexity in large systems.
This article provides a comprehensive, system‑engineer‑focused guide to Learning to Rank, covering fundamental machine‑learning concepts, evaluation metrics such as Precision, nDCG and ERR, training‑testing‑inference stages, pointwise/pairwise/listwise methods, and a detailed multi‑layer online ranking architecture with feature, model and recall governance.
The article explains how domain‑driven design helps software teams reach a shared understanding of the problem domain by cultivating requirements through visual collaboration, structured inception and iteration activities, and continuous feedback loops, ultimately improving architecture, reducing miscommunication, and delivering higher‑quality software.
This article explores practical Domain‑Driven Design in a B‑to‑B setting, comparing data‑centric and object‑centric modeling, illustrating blood‑loss, anemia, and rich models, and showing how dependency injection, testing strategies, repository abstractions, and deployment architectures can improve software quality and maintainability.
This article explains how to identify, design, and implement Java microservices—from domain‑driven modeling and service boundaries to RESTful API creation, documentation, proper HTTP verbs, and versioning strategies—using examples like an online retail store and the Game On! text adventure.
The article shares a senior engineer’s perspective on evolving payment system architectures—from a simple monolithic WAR package, through a duplicated “chimney” style, to a fully modular micro‑service platform—highlighting why each generation fits different business stages and how domain‑driven design supports rapid market growth.
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.
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.
This article introduces Lombok as a Java code‑simplification tool, explains how to install the IDEA plugin and add the Maven dependency, demonstrates basic and advanced annotation usage, discusses domain‑driven design models, and shows how Lombok can be combined with FreeMarker and MyBatis for automatic code generation.
This article shares a payment company's experience planning and executing a microservice transformation, covering the initial blueprint, implementation roadmap, current architectural challenges, key design debates, and the final target architecture diagram to guide a systematic migration.
This article shares the author's experience and lessons learned from a two‑day intensive discussion on microservice migration, outlining a concrete implementation plan, current architectural challenges, key debates, and the final target architecture blueprint for a third‑party payment company.
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 explores how to apply Domain‑Driven Design principles to structure and simplify a complex e‑commerce transaction system, detailing sub‑domain division, model refinement, core order‑service design, and the use of design patterns to achieve a maintainable backend architecture.
This article explains how to apply Domain‑Driven Design's domain events to separate reply handling from push notification logic, discusses the shortcomings of embedding side‑effects directly, compares Spring and Guava event mechanisms, and provides a custom Guava‑based publisher implementation with synchronous and asynchronous buses.
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.
This article explores the definitions of SOA and DDD, explains DDD's layered architecture, demonstrates how business relationships become domain models, and provides concrete C# examples of repositories, services, and factories to illustrate the integration of service‑oriented architecture with domain‑driven design.
This article discusses the challenges of building large distributed systems, emphasizing the need for a unified internal language, model‑driven design, layered architecture, and clear interface design principles to improve communication, maintainability, and scalability.
This article analyzes the unique complexities of China's 12306 train ticketing system, proposes a domain‑driven aggregate model centered on train trips, explains seat‑allocation rules and overlapping interval handling, and outlines a CQRS and event‑sourcing architecture to achieve strong consistency and high concurrency.
The article analyzes the complex business rules of China's 12306 train ticketing platform, proposes a domain‑driven design where the train aggregate root manages seat inventory and interval overlap, and outlines a CQRS/event‑sourcing architecture to achieve strong consistency and high concurrency.
This article analyses the unique business complexity of China's 12306 railway ticketing system, proposes a domain‑driven aggregate design centered on the train route, explains how to model seat availability and ticket issuance, and outlines a CQRS/event‑sourcing architecture to achieve strong consistency and high concurrency.
The article explains how over‑complex mental models, poor translation of semantic ideas into code, inadequate naming, missing design chunks, unclear usage patterns, and lack of smooth model transitions cause code to decay, and offers practical principles such as DDD, SRP, good naming, testing, and reusing existing algorithms to maintain readability.
