This article outlines five major technical gaps developers must bridge to become architects: shifting from monolithic to distributed thinking, mastering system design over feature coding, evolving from solo work to team collaboration, aligning technology with business strategy, and adopting cloud-native DevOps practices.
This article argues that Java developers adopt Lombok as a compromise against dogmatic encapsulation that mandates getters/setters for fields rarely needing custom logic, while also criticizing unnecessary interface/impl splits and DTO naming conventions, illustrated by a case where a getter enabled quick refactoring across hundreds of call sites.
This article breaks down six commercial bank fee categories — handling fees, commissions, management fees, service fees, risk commitment fees, and material fees — explaining their distinct legal nature, typical examples, and how they map to a domain-driven charging domain in banking software architecture.
The article explains CQRS as domain model separation rather than database read/write splitting, detailing command/query model boundaries, event-driven synchronization challenges, consistency trade-offs, engineering pitfalls like event reliability and view explosion, when to avoid CQRS, and a reference e-commerce order implementation with consistency-based query routing.
A real e-commerce stress test reveals a distributed monolith where services are physically separated but logically coupled via shared databases, synchronous write chains, and shared domain models. The article dissects three coupling layers, control-plane risks, and an incremental decoupling strategy with an architectural review checklist.
This article presents four reusable reasoning models for financial system architecture: phased FX cost optimization via netting, Boolean logic for regulatory boundary analysis, anemic vs rich domain model trade-offs for cross-module data transfer, and decomposing FX transactions into paired same-currency payments to simplify complex designs.
The article maps the official five-category classification of agency precious metals business against actual product lines at ICBC, China Merchants Bank, and Minsheng Bank, reveals that account precious metals (paper gold) have been phased out since 2021 due to regulatory reclassification as derivatives and the 'Oil Treasure' fallout, and contrasts paper gold with the now-favored accumulation gold across eight dimensions including leverage, physical delivery, and target users.
This article breaks down Palantir's four prioritized ontology modeling principles—domain-driven design, DRY with Rule of Three, open/closed extension, and composition over inheritance—illustrating each with concrete anti-patterns and a practical 12-question review checklist to prevent model fragmentation as teams scale.
This article explores architectural decomposition for a cement industrial platform, distinguishing business, code, and deployment boundaries, advocating modular monoliths over premature microservices, and detailing domain-driven design, bounded contexts, transaction boundaries, CQRS, and a practical migration strategy with evaluation criteria.
This article demonstrates how ValidX, a JSR-380-compliant validation library with 100+ Chinese business validators, integrates into DDD layered architecture, showing annotation-based DTO validation, chain-style API for value objects, aggregate roots, and domain services, with code examples for each layer and best practices for avoiding common pitfalls.
This article analyzes the practical limits of semantic decoupling through ontology models, showing that while field renames and stable contracts can be isolated via mapping layers, rule changes require verified data and computation, and new actions demand real execution paths — value lies in precisely scoping change impact, not promising zero development.
This article analyzes two extremes of microservice splitting—overly coarse services that become monoliths and overly fine services that explode call chains—details a three-tier technical debt classification (P0/P1/P2), and presents a four-step Strangler Fig Pattern for zero-downtime progressive refactoring based on real e-commerce production experience.
architecture governancedomain-driven designe-commerce case study
This article presents a three-tier framework for deploying ontology products—Starter (single-scenario pilot), Growth (domain-level iteration), and Mature (enterprise semantic layer)—with criteria for tier selection, delivery methods, deliverables, team structures, commercial models, key metrics, risks, and upgrade paths, emphasizing effect-first validation and explicit gap disclosure.
This article explains how FDE creates a business source model from field evidence, defining roles, a five-step convergence process, traceability to engineering artifacts, and baseline release criteria, ensuring business semantics are confirmed, conflicts preserved, and models constrain implementation without replacing source systems.
This article explains how event sourcing replaces synchronous call chains with domain events to decouple microservices, detailing the four core event elements, a three-step publish-subscribe flow using Spring Cloud Stream, and a practical template for implementation.
This article explains why effective service boundaries require aligning business rules, data ownership, change rhythms, and team responsibilities—not just drawing boxes around nouns—using a refund processing case study to compare modular monolith vs. microservice trade-offs and verify boundaries through concrete evidence.
The article walks through why embedding a wallet in the order service leads to boundary violations and failures under load, and presents a step‑by‑step evolution from an order‑centric wallet to a dedicated, event‑driven accounting center that ensures consistency, auditability, and high‑throughput scalability.
The article walks through a real e‑commerce payment case, showing how Domain‑Driven Design models entities, uses two key questions to split responsibilities, and continuously evolves the model to accommodate discounts, VIP features, and new payment adapters, reducing code churn.
The article presents a real‑world case of a ride‑hailing system whose microservices became tangled, and shows how applying Domain‑Driven Design—through strategic design, a six‑step refactoring roadmap, tactical four‑layer architecture, and context mapping—can systematically restore clean, business‑driven services.
This article analyzes microservice architecture decay through a real e-commerce case study, detailing root causes of circular dependencies (direct and indirect), four practical elimination strategies (domain events, shared contexts, data snapshots, context merging), ongoing governance practices (visualization, review gates, dependency classification), and a six-step iterative boundary reconstruction process to maintain architectural quality during continuous business evolution.
This article details a production-ready event-driven architecture for DDD microservices, covering the complete domain event flow, local event table for message loss prevention, three idempotency patterns for duplicate consumption, ordering solutions, five common pitfalls, and a five-layer eventual consistency architecture.
This article provides a step-by-step methodology for splitting bounded contexts after event storming, covering four golden rules (transaction consistency, change frequency, semantic uniqueness, team boundaries), an e-commerce case study, communication patterns, common pitfalls, and a mapping formula from contexts to microservices.
This tutorial teaches Event Storming, a Domain-Driven Design technique for defining microservice boundaries, through a five-step process (identify actors, commands, events, aggregates, bounded contexts) demonstrated with an e-commerce order example, plus mapping to DDD layered architecture and common pitfalls.
The article explains how to evolve a DDD‑based domain model into a cross‑system ontology that provides AI agents with unified facts, computable logic, and executable actions, using a six‑step process illustrated by a customer‑health‑score case and detailed governance practices.
This article explores service-based architecture as a practical distributed architecture style that offers independent deployment benefits without the complexity of microservices, covering its topology, domain services, API gateway, data topology, risks, characteristic scores, suitable scenarios, and team topology alignment.
This guide explains Domain‑Driven Design (DDD) and shows how to structure Spring Boot microservices by organizing code around business domains, detailing strategic and tactical concepts, package layouts, layer responsibilities, cross‑domain communication, comparisons with traditional layering, evolution steps, and common FAQs.
The article explains why solid architecture matters for Java projects, outlines seven mainstream architectural patterns—including layered, DDD, hexagonal, clean, CQRS, event‑driven, and microkernel—and provides a decision guide to help teams choose the most suitable approach based on complexity, experience, performance, and evolution needs.
This article explains why 90% of teams fail at microservice decomposition, details three common anti-patterns, and provides a complete DDD-based four-step process for defining bounded contexts, modeling aggregates, and implementing strategic and tactical patterns to eliminate distributed monoliths and reduce distributed transactions.
This article explores modular monolith architecture, comparing monolithic vs modular structures, peer-to-peer vs mediator communication patterns, characteristic ratings (cost, simplicity, modularity, deployability, maintainability, elasticity, fault tolerance), suitable and unsuitable scenarios, and aligned team topologies based on Fundamentals of Software Architecture.
This article explains how CQRS splits write operations that enforce business rules using domain models from read operations optimized for page performance, illustrates common pitfalls of mixing the two, and provides concrete Java code, SQL examples, migration steps, validation checklists, and best‑practice guidelines for implementing lightweight CQRS in a DDD‑based backend.
The article explains why cross‑aggregate business logic belongs in domain services, how domain events capture immutable business facts, and demonstrates practical Spring Boot implementations—including in‑process publishing, message‑queue integration, and the Outbox pattern—while highlighting pitfalls and verification techniques.
Learn how to tell whether a domain concept is an Entity or a Value Object by asking if its identity matters or only its attributes, see concrete examples with Money, Address and Order, understand immutable design, proper equals/hashCode implementation, and validation through unit tests.
This chapter explains how to strategically allocate modeling effort in a DDD project by distinguishing domains, subdomains, core, supporting, and generic subdomains, using the “Preferred Store” case to illustrate which areas merit detailed modeling and which can remain simple, ultimately guiding resource focus and decision‑making.
The article shows how a typical three‑layer OrderService accumulates scattered business rules, mixes technical details with domain logic, lacks clear boundaries, and diverges from business language, then explains how Domain‑Driven Design reorganizes code around aggregates and bounded contexts to solve these problems while outlining when DDD is unnecessary.
The article recounts a 12,000‑line UserService.java file, explains how the overly generic name masks multiple responsibilities, violates the single‑responsibility principle, and creates a distributed monolith, then shows how domain‑driven naming and bounded‑context splitting can restore clear architecture.
Single Responsibility Principledomain-driven designmicroservices
The article examines a payroll bug caused by exposing internal collections, then explains three immutable‑focused rules for aggregate roots—expose only through the root, keep each transaction to a single aggregate, and reference other aggregates by ID only—showing how proper design prevents consistency errors, performance loss, and concurrency conflicts in Spring Boot applications.
Facing a large version release that made the existing MVC three‑layer system hard to maintain, the author outlines the shortcomings of thin entity models, scattered service logic, and code bloat, then presents a DDD‑based four‑layer architecture with domain‑driven design, DIP, and CQRS to improve cohesion, reduce complexity, and support long‑term evolution.
The article explains how bounded contexts, defined by language boundaries rather than functional ones, guide the logical separation of a payroll system into distinct domains, illustrating the process with concrete terminology lists, ambiguity detection, authority mapping, code examples, and deployment‑agnostic module structures.
This article explains core architecture design principles—including layered, hexagonal, and COLA structures—covers cohesion and coupling types with evaluation criteria, presents practical strategies to reduce coupling, and details domain‑driven design concepts such as bounded contexts, aggregates, and repository patterns, all illustrated with concrete code examples and decision records.
The article shows how mismatched business and code vocabularies cause confusion, then guides readers through building a shared glossary, renaming domain objects and types in Java, and enforcing the conventions with a code‑review checklist to keep the ubiquitous language alive in the codebase.
The article explains why traditional three‑layer architectures let business logic bloat inside services, demonstrates the pitfalls of anemic domain models with a 7,000‑line SalaryService example, and shows how DDD’s rich domain model restores rule ownership and maintainability.
The article explains how architects can bridge high‑level platform diagrams and concrete implementation by using DDD‑based module functional diagrams that serve as prompts for AI code generation, avoiding low‑level detail while ensuring domain understanding guides development.
The article analyzes whether endorsement (policy changes) and policy management should reside in a single microservice or be split into two, weighing data consistency, cohesion, operational simplicity, scaling, deployment independence, fault isolation, team size, and compliance, and provides a concrete decision framework and split strategy.
This article compiles first-principles design philosophies from ten software engineering leaders, including LLVM creator Chris Lattner and Perfetto expert Lalit Maganti, showing how to break problems to fundamental constraints rather than copying existing solutions.
The article argues that business architecture, ontology, knowledge graphs, and business object digitalization form a sequential four-level chain—governance boundaries, semantic definitions, instance relationships, and operational implementation—that must be built in order to achieve consistent enterprise-wide object identity and avoid failed digitalization efforts.
business architecturebusiness object digitalizationdigital transformation
The article clarifies that microservices are defined by business‑capability‑aligned, independently deployable services—not merely smaller services—detailing five core mechanisms, distributed‑system constraints, SOA comparison, and five common misconceptions.
CAP theoremDistributed SystemsIndependent Deployment
The article explains that CQRS originates from CQS, separates command and query responsibilities, clarifies its relationship with Event Sourcing and DDD, debunks four common misconceptions, and shows how it trades complexity for freedom when write and read optimizations conflict.
The article explains that Onion Architecture’s essence lies in inward‑facing dependencies rather than the visual onion shape, details its six‑layer structure, clarifies common misconceptions, and compares it with Clean and Hexagonal architectures to show how it improves testability and replaceability.
The article compares the classic Event Sourcing + CQRS architecture with the more engineering‑focused read‑write separation CQRS, outlining their workflows, advantages, drawbacks, and guiding criteria for selecting the appropriate design in real‑world projects.
The article argues that Domain‑Driven Design is not an architectural style but a two‑layer framework—strategic design defines bounded contexts and ubiquitous language, while tactical design supplies the modeling tools—explaining common misreadings and showing how DDD complements Clean, Hexagonal, CQRS, and Event Sourcing approaches.
The article explains that software architecture is fundamentally about trade‑offs, categorises major architecture families such as DDD, Clean/Hexagonal/Onion, Microservices vs SOA, CQRS/Event Sourcing, MVC, PACELC, BASE, FLP, Repository and 12‑Factor principles, and shows how each addresses specific constraints to help engineers pick the most suitable design for their context.
A comprehensive practical guide to implementing Domain-Driven Design in complex business systems, covering bounded context division using Event Storming and subdomain analysis, aggregate root and entity design with code examples, domain event patterns for decoupling and eventual consistency, and integrating DDD with Spring Boot's layered architecture using onion/clean architecture principles.
The article explains how Domain‑Driven Design addresses the pitfalls of bloated services, unclear boundaries, and inconsistent terminology by introducing bounded contexts, aggregates, and domain events, and outlines a step‑by‑step adoption process while debunking common misconceptions.
The article examines whether services must adhere to strict layered calls in DDD, explains the layered‑to‑COLA refinement, describes the “sinkhole” anti‑pattern caused by excessive pass‑through interfaces, and offers criteria such as the 80‑20 rule for deciding when to open a layer.
The author recounts three years of applying Domain‑Driven Design to a microservice ecosystem, sharing concrete pitfalls, code‑first modeling from database tables, and a structured 24‑article series that guides developers to refactor existing Spring Boot + MyBatis Plus projects without rewriting the framework.
Domain-Driven Design (DDD) centers software architecture on business domains, breaking complex problems into clear subdomains, defining bounded contexts, ubiquitous language, and key building blocks such as entities, value objects, and aggregates, while guiding layered architecture and microservice decomposition for maintainable, collaborative systems.
This article explains why domain models are needed, walks through DDD's strategic and tactical design concepts, demonstrates a full knowledge‑payment platform case with bounded contexts, aggregates, and ubiquitous language, and outlines practical guidelines and limitations for applying DDD in real projects.
This article explores how to model clean, high‑cohesion Go structs using Domain‑Driven Design, value objects, entities, services, and proven patterns like functional options, builders, specifications, and repositories, illustrated with e‑commerce and payment system examples.
This guide shows how to break down tangled Java services using Domain‑Driven Design and Command‑Query Responsibility Segregation, providing concrete terminology, layered diagrams, code examples, and step‑by‑step migration strategies to improve maintainability, performance, and team communication.
The article explains why returning a generic Result wrapper from a Java service layer breaks responsibility separation, harms reusability, complicates exception handling and testing, and obscures transaction boundaries, advocating for returning pure domain objects instead.
The article explains that returning a Result wrapper from the Service layer mixes business logic with presentation concerns, leading to tighter coupling, reduced reusability, cumbersome error handling, harder testing, poorer DDD alignment, limited interface flexibility, and ambiguous transaction boundaries.
A three‑year‑old Java module riddled with technical debt was systematically refactored using AI tools, following a four‑stage plan of analysis, problem identification, solution design, and incremental implementation, while establishing rigorous verification to ensure safety and quality.
This article presents a detailed case study of using AI to assist domain‑driven design (DDD) for refactoring Taobao's monolithic flash‑sale service‑package system, showing how automated context extraction, code skeleton generation, and AI‑augmented implementation reduced development effort from 5‑8 person‑days to a configurable solution while improving architecture decoupling, code quality, and extensibility.
This article explains how hexagonal architecture serves as a solid foundation for gradually introducing domain‑driven design, outlines the stages of evolution, highlights common pitfalls, and provides concrete code examples to help teams decide when to move beyond hexagonal alone.
This article explains the fundamentals of Domain‑Driven Design, its core principles and two design phases, then shows how to apply DDD within a Spring Cloud Alibaba e‑commerce microservice system, providing a detailed layered architecture, file‑structure example, and recommendations for implementation.
This article examines how a rapidly growing Taobao flash‑sale service‑package system suffered from high development costs, duplicated code, and tight coupling, and shows how AI‑assisted domain‑driven design was applied to refactor the architecture, automate code generation, and dramatically improve efficiency, maintainability, and extensibility.
Using AI to assist domain-driven design, this case study details how a monolithic Taobao service-package system was analyzed, restructured, and refactored, reducing development effort from 5-8 person-days per package to configuration-based implementation while eliminating duplicated code and improving modularity, testability, and scalability.
The article explains how the COLA‑DDD layered architecture merges Clean Object‑Oriented and Layered Architecture with Domain‑Driven Design to eliminate large‑muddy code, improve iteration speed, enhance scalability, and provide clear layer boundaries, CQRS, event‑driven processing, and low‑risk technical evolution.
The article explains how a capacity‑driven microservice architecture uses performance metrics like QPS, TPS, and latency as the primary split criterion, detailing design principles, module responsibilities, and practical benefits that enable systems to handle traffic spikes without service collapse.
This article examines how early PHP developers often wrote tangled, procedural code that mixes business logic with presentation, and outlines concrete steps—adopting OOP, design patterns, domain‑driven design, test‑driven development, and modern tooling—to shift toward a cleaner, more maintainable backend development approach.
The article shares the author's practical frustrations with Domain‑Driven Design—covering confusing CQRS classifications, ambiguous aggregate‑root boundaries, performance conflicts, and the high time cost—while offering concrete examples, code snippets, and a candid conclusion that DDD should be applied judiciously rather than dogmatically.
This article explains what constitutes a complex system, defines software architecture, explores various architecture types, outlines key design factors, presents analysis methods like DDD, and reviews typical solutions such as microservices, cloud‑native, DevOps, and big‑data architectures for building robust, scalable systems.
Complex systems are composed of many interacting components, and understanding their architecture—from business and application layers to technical, data, microservice, cloud‑native, and DevOps designs—requires grasping core principles, requirements, and design patterns that ensure reliability, scalability, and long‑term value.
This article explores the essential role of modeling in software engineering, outlines the three main types of modeling, examines why modeling remains a persistent challenge due to language ambiguity and real‑world complexity, and provides practical guidance on business and domain modeling for architects.
After analyzing thousands of Chinese projects, the article reveals seven pervasive architecture design pitfalls—overreliance on frameworks, chasing trends, neglecting domain modeling, ignoring evolution, overlooking non‑functional requirements, lacking team standards, and weak testing—offering practical guidance to adopt business‑driven, scalable, maintainable designs.
This article explains how mastering business modeling, requirements analysis, and UML techniques—rather than focusing solely on code—helps developers create software that truly solves real business problems and drives profit, using lessons from the classic book “Software Method”.
This article explains how Event Storming—a collaborative, sticky‑note‑driven workshop—helps teams break down complex business processes into events, commands, aggregates and policies, dramatically speeding up requirements analysis, improving model quality, and turning the resulting model directly into code and living documentation.
This article explores the essence of software architecture, tracing its definition, its role in solving division‑of‑labor challenges, and how a pragmatic, balanced design that treats architecture as software design itself can deliver sustainable value while navigating business complexity, team coordination, and evolving requirements.
This article explains the fundamentals of hexagonal (ports‑and‑adapters) architecture, presents three ways to implement it in Spring Boot—including a classic version, a DDD‑enhanced version, and a simplified variant—while analyzing their advantages, disadvantages, and suitable scenarios.
This article explains how Domain‑Driven Design (DDD) complements microservice architecture by addressing functional partitioning gaps, guiding system decomposition, and improving scalability, while also highlighting common microservice pitfalls and practical steps for clear bounded‑context modeling.
This article introduces the fundamentals of Domain‑Driven Design (DDD), explains key concepts such as rich domain models, entities, value objects, aggregates, repositories, adapters, and application orchestration, and demonstrates their implementation through comprehensive Java code examples and a complete project structure diagram.
This article explains why overly fine‑grained service splitting hurts performance and debugging, shows best‑practice granularity aligned with team size, introduces evolutionary splitting based on model responsibilities, and walks through real‑world case studies, domain‑driven design concepts, architectural patterns such as hexagonal, CQRS, and event‑driven designs, and practical steps for building a robust service‑oriented system.
This article explains how the increasing complexity of business logic in modern backend systems leads to tangled code, and demonstrates how strategic and tactical Domain‑Driven Design (DDD) concepts—such as bounded contexts, aggregates, entities, value objects, repositories, and application services—can decouple business and technology, improve maintainability, extensibility, and stability, and guide practical layered architecture implementation.
This article shares a two‑and‑a‑half year effort to standardize code style and architecture across a large Java backend, detailing the origins, evolving patterns, a unified layered model, concrete implementation examples, measurable benefits, and future directions for continuous improvement.
Domain‑Driven Design (DDD) aligns software structure with business concepts by embedding rules in rich domain models, using aggregates, domain services, and events, contrasting with traditional anemic layers, and is ideal for complex, evolving domains such as e‑commerce, finance, or ERP systems.
This article explores how Domain‑Driven Design and hexagonal (clean) architecture were applied to Huolala’s user CRM, detailing the tactical design patterns, module breakdown, code examples, and the step‑by‑step migration that improved scalability, maintainability, and development efficiency.
This article explains Domain-Driven Design (DDD), contrasting it with traditional layered development through clear examples, outlines key DDD building blocks such as aggregate roots, domain services, and events, and discusses when DDD is appropriate for complex, frequently changing business domains.
The article explains that while encapsulation, inheritance, and polymorphism are often highlighted, true software craftsmanship hinges on the ability to abstract—identifying essential features, discarding irrelevant details, and modeling problem domains through steps like analysis, concept extraction, and system design, supported by principles such as low coupling, high cohesion, sufficiency, and completeness.
The article explains why developers must combine deep business understanding with AI tools, outlines a three‑layer domain model (core, generic, supporting), debunks common misconceptions, and provides a step‑by‑step methodology for mastering banking business concepts to boost ROI and career resilience.
AI IntegrationProcess Improvementdomain-driven design
The article explains how Domain‑Driven Design combined with microservice architecture can restructure a monolithic transaction system by defining bounded contexts, applying patterns such as layered architecture, CQRS and event‑driven communication, and refactoring domains to improve maintainability, scalability, and business clarity.
The article explains the DDD rich (or active) model, its core characteristics, compares it with the anemic model, and shows how to apply it in a shared‑rental billing domain using Java, DDD layers, domain events, and a lightweight framework.
This article discusses why and how to split monolithic applications into microservices, outlining common pitfalls of over‑splitting and presenting practical principles such as team and domain isolation, the three‑person rule, read/write separation, dependency management, and service count guidelines.
This article compares Domain‑Driven Design and MVC, outlines the architectural changes such as dependency inversion and layer separation, examines common drawbacks in real projects, and offers concrete guidance on when to adopt DDD, blend it with MVC, or stick to a lightweight CRUD‑centric approach.
This article explores the practical application of Domain‑Driven Design and hexagonal architecture in a real‑world CRM system, detailing strategic and tactical design, module division, code examples, and a step‑by‑step migration from a traditional layered architecture to a more flexible, maintainable backend solution.
The article proposes a domain‑model‑driven code paradigm—defining clear business models, core domain objects, and infrastructure abstractions like repositories, facades, and factories—while contrasting it with process‑driven designs using ability nodes and chains, arguing that these patterns cut repetitive effort and boost maintainability.
This comprehensive guide walks readers through the entire system design process, covering problem definition, key concepts, system analysis, modeling techniques, architectural thinking, design tools, requirements gathering, domain‑driven and use‑case modeling, design principles, patterns, and practical architecture delivery.
The team concluded that adopting Domain‑Driven Design can be valuable, but only when a company can afford the upfront investment, has a shared language and cross‑department collaboration, possesses strong OOP expertise, and maintains a culture supportive of the required organizational change.
This article provides a comprehensive overview of Domain-Driven Design (DDD), explaining its core principles, layered architecture, domain model components such as entities, value objects, aggregates, and bounded contexts, and includes Java code examples to illustrate implementation.