This article explains the Command‑Query Separation principle, introduces three CQRS architectures—single‑database, dual‑database, and event‑sourced—and discusses their benefits, trade‑offs, and how they enable separate optimization of read and write operations.
This article explains the fundamentals of Domain‑Driven Design, covering the importance of a correct domain model, the layered architecture (presentation, application, domain, infrastructure), building blocks such as entities, value objects, services, aggregates, repositories, factories, and advanced topics like CQRS, Event Sourcing, Unit of Work, DCI, and the four‑color archetype analysis.
This article explains the fundamental notion of software architecture, why it is needed, the responsibilities of architects, various architecture classifications, typical application architectures such as layered, CQRS, hexagonal and onion models, and introduces Alibaba's open‑source COLA framework with its layered design, extension mechanisms and standards.
This article explains what software architecture is, why it is needed, the responsibilities of architects, various architecture classifications, common architectural styles such as layered, CQRS, hexagonal and onion, and introduces the COLA application architecture with its layered design, extension mechanisms and normative guidelines.
This article explains the fundamentals of Domain-Driven Design, describing how a shared ubiquitous language and a well‑crafted domain model drive software architecture across presentation, application, domain, and infrastructure layers, and it covers key patterns such as aggregates, entities, value objects, repositories, CQRS, Event Sourcing, and DCI.
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 examines the chronic decay of a long‑standing warehouse inventory system, identifies its tangled business boundaries, chaotic architecture, and uncontrolled delivery efficiency, then presents a domain‑driven design solution with clear modeling, onion‑style layering, CQRS, and practical implementation steps to restore maintainability.
The article explores how enterprises can reduce tight coupling in microservice architectures by converting synchronous calls to asynchronous messaging, adopting message‑oriented middleware, applying event‑driven analysis, and leveraging CQRS patterns, while also offering practical refactoring tactics for overly coupled services.
This article introduces six essential cloud‑native design patterns—Circuit Breaker, CQRS, Event Sourcing, Sidecar, BFF, and Strangler—explaining their purpose, implementation tips, and when to apply or avoid them to build scalable, resilient, and maintainable enterprise systems.
The article explains how a team building a SQL Server data catalog decided to decouple persistence by moving ID generation from the database to the domain layer, adopting 64‑bit Snowflake‑style identifiers instead of auto‑increment keys or UUIDs to improve flexibility, scalability, and performance.
The article examines how to reduce tight coupling between microservices by applying module‑division principles, converting synchronous calls to asynchronous messaging, leveraging event‑driven architectures and CQRS, employing local caching and data landing, and refactoring overly coupled services for more resilient backend systems.
This article explains the concept of Explicit Architecture, describing how core modules, tools, ports, adapters, and component organization combine hexagonal, onion, clean, and CQRS patterns to achieve a loosely‑coupled, highly‑cohesive software system suitable for both monolithic and micro‑service applications.
This article explains the fundamentals of microservice architecture, outlines its advantages and disadvantages, describes when it should be adopted, and details ten essential design patterns—including database per service, event sourcing, CQRS, Saga, BFF, API gateway, Strangler, circuit breaker, externalized configuration, and consumer‑driven contract testing—providing practical guidance and technology examples for modern backend systems.
This article surveys the evolution of software complexity, defines microservice architecture, outlines its key advantages and drawbacks, and then details ten crucial design patterns—including database per service, event sourcing, CQRS, saga, BFF, API gateway, strangler, circuit breaker, externalized configuration, and consumer‑driven contract testing—while explaining when each should be applied.
This article explains the challenges of cross‑service communication in microservice architectures and presents a comprehensive set of design patterns—including synchronous and asynchronous messaging, event‑driven approaches, saga, event sourcing, CQRS, outbox, CDC, idempotency, eventual consistency, distributed tracing, and service mesh—to help engineers build reliable, scalable distributed systems.
This article defines software architecture, explains why it is essential, outlines the architect's responsibilities, categorizes various architecture types, and details common patterns such as layered, CQRS, hexagonal, onion, and the open‑source COLA framework with its design and extension principles.
This article explains how event sourcing models state changes as immutable logs, discusses its advantages and drawbacks, shows how CQRS separates command and query responsibilities, and demonstrates how Apache Kafka and Kafka Streams enable scalable, fault‑tolerant implementations with real‑world examples.
This article explains the concept of software architecture, why it is essential, the responsibilities of architects, various architecture classifications, and introduces practical application architectures such as layered, CQRS, hexagonal, onion, and the open‑source COLA framework, highlighting how separating business logic from technical details improves maintainability and scalability.
This article explains the Command‑Query Separation principle, introduces the CQRS architectural pattern, and compares three implementations—single‑database, dual‑database, and event‑sourced—detailing their workflows, benefits, and trade‑offs for optimizing read and write operations in backend systems.
This article explains the Command‑Query Separation principle and introduces three CQRS architectures—single‑database, dual‑database, and event‑sourced—detailing how separating reads and writes can improve performance while highlighting the added complexity each approach brings.
This article explores how Domain‑Driven Design helps the Tongtian Tower platform manage rapidly growing business complexity by separating business and technical concerns, introducing strategic and tactical design, bounded contexts, layered and hexagonal architectures, and complementary patterns such as CQRS and domain primitives.
This article explains what software architecture is, why it is essential, the responsibilities of architects, various classification types, common patterns such as layered, CQRS, hexagonal and onion architectures, and introduces the open‑source COLA framework with its layered design, extension mechanisms, and specification rules.
This article explains the concept of software architecture, why it is needed, the responsibilities of architects, various architectural classifications and patterns such as layered, CQRS, hexagonal and onion architectures, and introduces the COLA framework with its layered design, extension mechanisms, and specification guidelines.
This article explains what software architecture is, why it is essential, the responsibilities of architects, various classification types, typical architectural patterns such as layered, CQRS, hexagonal and onion architectures, and introduces Alibaba's open‑source COLA framework with its layered design, extension and specification concepts.
The article analyzes common coupling problems in microservice architectures and presents practical decoupling techniques—including asynchronous messaging, event‑driven design, local caching, data landing, and CQRS—while also offering refactoring guidelines for tightly coupled services.
This article analyzes the challenges of tightly coupled microservices and presents practical decoupling techniques—including asynchronous messaging, event‑driven architecture, CQRS, local caching, and service refactoring—to improve resilience and availability in modern backend systems.
This article discusses how to reduce coupling between microservices by converting synchronous calls to asynchronous messaging, employing message middleware, event‑driven architecture, CQRS patterns, local caching, data landing, and refactoring techniques such as merging services, extracting common modules, and adjusting granularity.
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.
The article examines why tightly coupled microservices cause reliability issues, then presents practical techniques—such as converting synchronous calls to asynchronous messaging, adopting event‑driven architecture, using CQRS, caching, and strategic refactoring—to achieve loose coupling and improve system resilience.
This article examines the CQRS (Command Query Responsibility Segregation) pattern, outlining its objectives, three major complexity traps—over‑isolated commands, event sourcing coupling, and excessive tooling—and offers practical mitigation strategies, including relaxed isolation, alternative projection techniques, and careful service decomposition.
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.
This article explains what software architecture is, why it is essential for any system, the responsibilities of architects, various architecture classifications, and introduces the COLA open‑source framework that combines layered, hexagonal, and onion architectures with CQRS and extensibility to separate business logic from technical details.
This article explains the CQRS pattern, contrasts it with traditional CRUD, outlines its architectural benefits, presents two implementation approaches—including shared and separate databases—and provides a step‑by‑step Java example with command interfaces, a CommandBus, and controller integration, helping developers adopt CQRS in real projects.
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.
The article describes Overwatch, a distributed monitoring system developed by Dada‑JD Daojia that collects, aggregates, and visualizes RPC traffic in real time using consumer‑side agents, Kafka, Storm, and a Node.js CQRS architecture, enabling engineers to quickly locate and resolve service failures.
Alibaba’s UED outsourcing platform integrates AI-driven image verification, DDD‑based architecture, CQRS, and API interfaces to streamline design task distribution, real‑time budgeting, automated settlement, and quality assessment, enabling efficient, controllable, and intelligent management of over 700 external designers across the group.
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.
This article explains the CQRS (Command Query Responsibility Segregation) and Event Sourcing patterns, outlines their benefits such as clearer logic, stability, and scalability, and discusses practical goals like separating core business logic, using pure functions, and achieving easier testing and horizontal expansion, while warning of added complexity.
This article details the evolution of Qunar's TTS pricing engine from a monolithic V1 implementation with dual-level caching and blocking HTTP interfaces to a scalable V2 architecture featuring service separation, asynchronous processing, CQRS-based rule storage, canal synchronization, Solr and Redis indexing, and Kafka-driven data pipelines.
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.
Overwatch is an open‑source distributed monitoring platform built by Dada‑Jingdong Home that collects, aggregates, and visualizes RPC traffic across thousands of micro‑services in real time, enabling engineers to quickly pinpoint the root cause of system failures using directed‑graph visualizations and CQRS‑based data queries.
The article examines the challenges of distributed transactions in large‑scale microservice architectures and compares three main approaches—traditional two‑phase commit, stateless queue‑based eventual consistency with event sourcing and CQRS, and transaction compensation techniques such as TCC—highlighting their trade‑offs and real‑world examples like Flipkart.
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 the lack of Command‑Query Responsibility Segregation (CQRS) leads to unnecessary complexity, outlines the benefits of read‑write separation, presents a simple e‑commerce example, and summarizes Vladimir Khorikov’s three CQRS types and when to apply them.
