BestHub
Sign in
Tagged articles

cqrs

144 articles · Page 2 of 2
Top Architect
Top Architect
Apr 30, 2021 · Fundamentals

Understanding Software Architecture: Concepts, Classifications, and the COLA Framework

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.

COLAOnion Architecturecqrs
0 likes · 13 min read
Understanding Software Architecture: Concepts, Classifications, and the COLA Framework
IT Architects Alliance
IT Architects Alliance
Apr 28, 2021 · Fundamentals

Understanding Software Architecture: Concepts, Classifications, and the COLA Application Architecture

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.

COLADesign PatternsOnion Architecture
0 likes · 12 min read
Understanding Software Architecture: Concepts, Classifications, and the COLA Application Architecture
Architecture Digest
Architecture Digest
Apr 8, 2021 · Fundamentals

Understanding Domain-Driven Design: Core Concepts, Layers, and Patterns

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.

AggregatesDomain-Driven DesignModeling
0 likes · 36 min read
Understanding Domain-Driven Design: Core Concepts, Layers, and Patterns
Yanxuan Tech Team
Yanxuan Tech Team
Mar 19, 2021 · Backend Development

How DDD Can Rescue a Decaying Warehouse Management System

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.

DDDOnion Architecturearchitecture
0 likes · 15 min read
How DDD Can Rescue a Decaying Warehouse Management System
NetEase Yanxuan Technology Product Team
NetEase Yanxuan Technology Product Team
Mar 19, 2021 · Backend Development

Refactoring a Legacy Warehouse System with Domain‑Driven Design

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.

Backend ArchitectureDomain-Driven DesignLegacy refactoring
0 likes · 15 min read
Refactoring a Legacy Warehouse System with Domain‑Driven Design
Architects' Tech Alliance
Architects' Tech Alliance
Feb 19, 2021 · Backend Development

Strategies for Decoupling Microservices: Asynchronous Calls, Message Middleware, Event‑Driven Architecture, and CQRS

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.

AsynchronousDecouplingMessage Middleware
0 likes · 20 min read
Strategies for Decoupling Microservices: Asynchronous Calls, Message Middleware, Event‑Driven Architecture, and CQRS
Top Architect
Top Architect
Feb 11, 2021 · Cloud Native

Modern Architecture Design Patterns for Scalable Applications

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.

BFFMicroservicesSidecar
0 likes · 11 min read
Modern Architecture Design Patterns for Scalable Applications
Selected Java Interview Questions
Selected Java Interview Questions
Jan 24, 2021 · Backend Development

Decoupling Microservices: Asynchronous Messaging, Event‑Driven Architecture, and CQRS Strategies

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.

asynchronous messagingbackend designcqrs
0 likes · 21 min read
Decoupling Microservices: Asynchronous Messaging, Event‑Driven Architecture, and CQRS Strategies
Architects Research Society
Architects Research Society
Jan 24, 2021 · Fundamentals

Explicit Architecture: Integrating Hexagonal, Onion, Clean, and CQRS Patterns

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.

Clean ArchitectureOnion Architecturecqrs
0 likes · 22 min read
Explicit Architecture: Integrating Hexagonal, Onion, Clean, and CQRS Patterns
Architecture Digest
Architecture Digest
Jan 22, 2021 · Backend Development

Microservice Architecture and Its Ten Most Important Design Patterns

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.

Design Patternscqrsdistributed systems
0 likes · 21 min read
Microservice Architecture and Its Ten Most Important Design Patterns
ITFLY8 Architecture Home
ITFLY8 Architecture Home
Jan 18, 2021 · Backend Development

10 Essential Microservice Design Patterns Every Backend Engineer Should Know

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.

API GatewayBackend ArchitectureDesign Patterns
0 likes · 24 min read
10 Essential Microservice Design Patterns Every Backend Engineer Should Know
Top Architect
Top Architect
Jan 8, 2021 · Backend Development

Microservice Architecture Communication Design Patterns

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.

MicroservicesSAGAcommunication
0 likes · 17 min read
Microservice Architecture Communication Design Patterns
ITPUB
ITPUB
Dec 30, 2020 · Fundamentals

What Is Software Architecture? Core Concepts, Patterns, and the COLA Framework Explained

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.

COLA frameworkDesign PatternsOnion Architecture
0 likes · 15 min read
What Is Software Architecture? Core Concepts, Patterns, and the COLA Framework Explained
Architects Research Society
Architects Research Society
Dec 18, 2020 · Backend Development

Event Sourcing, CQRS, and Kafka Streams: Architecture, Trade‑offs, and Practical Examples

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.

cqrsevent sourcingkafka streams
0 likes · 17 min read
Event Sourcing, CQRS, and Kafka Streams: Architecture, Trade‑offs, and Practical Examples
Programmer DD
Programmer DD
Nov 17, 2020 · Fundamentals

Why Good Software Architecture Matters: From Basics to the COLA Framework

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.

COLA frameworkOnion Architectureapplication design
0 likes · 16 min read
Why Good Software Architecture Matters: From Basics to the COLA Framework
IT Architects Alliance
IT Architects Alliance
Nov 12, 2020 · Backend Development

Mastering CQRS: Choose the Right Architecture – Single, Dual, or Event‑Sourced

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.

Backend ArchitectureCQSDesign Patterns
0 likes · 6 min read
Mastering CQRS: Choose the Right Architecture – Single, Dual, or Event‑Sourced
ITFLY8 Architecture Home
ITFLY8 Architecture Home
Nov 7, 2020 · Backend Development

Mastering CQRS: 3 Architectural Patterns to Boost Read/Write Performance

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.

CQSCommand Query SeparationDomain-Driven Design
0 likes · 6 min read
Mastering CQRS: 3 Architectural Patterns to Boost Read/Write Performance
IT Architects Alliance
IT Architects Alliance
Nov 2, 2020 · Backend Development

How DDD Can Tame Complex Business Logic in Modern Backend Systems

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.

Backend ArchitectureDomain modelingDomain-Driven Design
0 likes · 40 min read
How DDD Can Tame Complex Business Logic in Modern Backend Systems
IT Architects Alliance
IT Architects Alliance
Oct 28, 2020 · Fundamentals

Why Architecture Matters: From Basics to the COLA Open‑Source Framework

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.

COLADesign PatternsOnion Architecture
0 likes · 14 min read
Why Architecture Matters: From Basics to the COLA Open‑Source Framework
Architects' Tech Alliance
Architects' Tech Alliance
Oct 25, 2020 · Fundamentals

Understanding Software Architecture and the COLA Application Architecture

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.

COLAOnion Architecturecqrs
0 likes · 12 min read
Understanding Software Architecture and the COLA Application Architecture
ITFLY8 Architecture Home
ITFLY8 Architecture Home
Oct 23, 2020 · Fundamentals

Why Architecture Matters: From Basics to the COLA Framework

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.

COLA frameworkOnion Architecturecqrs
0 likes · 14 min read
Why Architecture Matters: From Basics to the COLA Framework
Architecture Digest
Architecture Digest
Sep 24, 2020 · Backend Development

Microservice Decoupling Strategies: From Synchronous Calls to Asynchronous Messaging, Event‑Driven Architecture, and CQRS

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.

AsynchronousDecouplingbackend
0 likes · 20 min read
Microservice Decoupling Strategies: From Synchronous Calls to Asynchronous Messaging, Event‑Driven Architecture, and CQRS
IT Architects Alliance
IT Architects Alliance
Sep 13, 2020 · Backend Development

How to Decouple Tight Microservices: Strategies, Messaging, and CQRS

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.

DecouplingMicroservicesarchitecture
0 likes · 21 min read
How to Decouple Tight Microservices: Strategies, Messaging, and CQRS
Architects' Tech Alliance
Architects' Tech Alliance
Sep 9, 2020 · Backend Development

Microservice Decoupling Strategies: Asynchronous Calls, Messaging, Event‑Driven Architecture, CQRS, and Refactoring

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.

DecouplingMicroservicesarchitecture
0 likes · 19 min read
Microservice Decoupling Strategies: Asynchronous Calls, Messaging, Event‑Driven Architecture, CQRS, and Refactoring
iQIYI Technical Product Team
iQIYI Technical Product Team
Sep 4, 2020 · Backend Development

Applying Axon Framework and Spring StateMachine in iQIYI Contract Platform: Architecture, Practices, and Lessons

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.

Axon FrameworkBackend ArchitectureDomain-Driven Design
0 likes · 11 min read
Applying Axon Framework and Spring StateMachine in iQIYI Contract Platform: Architecture, Practices, and Lessons
IT Architects Alliance
IT Architects Alliance
Jul 29, 2020 · Backend Development

How to Decouple Microservices: From Sync Calls to Event‑Driven Architecture

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.

Backend ArchitectureDecouplingMessage Queue
0 likes · 21 min read
How to Decouple Microservices: From Sync Calls to Event‑Driven Architecture
High Availability Architecture
High Availability Architecture
May 11, 2020 · Backend Development

Understanding CQRS Complexity: Goals, Common Pitfalls, and Practical Solutions

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.

Design PatternsMicroservicesbackend
0 likes · 10 min read
Understanding CQRS Complexity: Goals, Common Pitfalls, and Practical Solutions
vivo Internet Technology
vivo Internet Technology
Apr 8, 2020 · Backend Development

Applying Domain Events, Saga, and CQRS in Domain-Driven Design

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.

Domain EventsDomain-Driven DesignSAGA
0 likes · 21 min read
Applying Domain Events, Saga, and CQRS in Domain-Driven Design
Alibaba Cloud Developer
Alibaba Cloud Developer
Aug 29, 2019 · Fundamentals

Why Architecture Matters: Unpacking Application Design Principles and the COLA Framework

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.

COLA frameworkOnion Architectureapplication design
0 likes · 14 min read
Why Architecture Matters: Unpacking Application Design Principles and the COLA Framework
Java Backend Technology
Java Backend Technology
Jul 20, 2019 · Backend Development

Mastering CQRS: How to Split Commands and Queries for Scalable Java Backends

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.

Command Buscqrsjava
0 likes · 8 min read
Mastering CQRS: How to Split Commands and Queries for Scalable Java Backends
Java Captain
Java Captain
Jun 19, 2019 · Backend Development

Understanding Domain-Driven Design (DDD) and Its Role in Solving CRUD Problems

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.

CRUDDDDDomain-Driven Design
0 likes · 29 min read
Understanding Domain-Driven Design (DDD) and Its Role in Solving CRUD Problems
JD Tech
JD Tech
Apr 17, 2018 · Operations

Overwatch: A Distributed Real‑Time RPC Monitoring Platform for System Observability

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.

Distributed MonitoringRPCcqrs
0 likes · 8 min read
Overwatch: A Distributed Real‑Time RPC Monitoring Platform for System Observability
Alibaba Cloud Developer
Alibaba Cloud Developer
Dec 27, 2017 · Artificial Intelligence

How Alibaba’s AI‑Powered UED Platform Transforms Design Outsourcing

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.

AI verificationAlibabaDesign Platform
0 likes · 9 min read
How Alibaba’s AI‑Powered UED Platform Transforms Design Outsourcing
Alibaba Cloud Developer
Alibaba Cloud Developer
Dec 15, 2017 · Backend Development

Taming Enterprise Application Complexity: Extension Points, CQRS & DDD

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.

DDDSOLIDbackend
0 likes · 17 min read
Taming Enterprise Application Complexity: Extension Points, CQRS & DDD
Node Underground
Node Underground
Dec 12, 2017 · Backend Development

Mastering CQRS and Event Sourcing: Clean, Scalable Backend Design

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.

cqrsevent sourcingscalability
0 likes · 3 min read
Mastering CQRS and Event Sourcing: Clean, Scalable Backend Design
Qunar Tech Salon
Qunar Tech Salon
Nov 28, 2017 · Backend Development

Optimizing the TTS Pricing Engine: From Monolithic V1 to Scalable V2 Architecture

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.

Data synchronizationPricing EngineRedis
0 likes · 10 min read
Optimizing the TTS Pricing Engine: From Monolithic V1 to Scalable V2 Architecture
Meituan Technology Team
Meituan Technology Team
Oct 26, 2017 · Backend Development

Domain-Driven Design Q&A: Event Handling, Service Design, and Domain Boundaries

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.

DDDDomain-Driven DesignMicroservices
0 likes · 6 min read
Domain-Driven Design Q&A: Event Handling, Service Design, and Domain Boundaries
Dada Group Technology
Dada Group Technology
Sep 29, 2017 · Operations

Overwatch: A Distributed System Monitoring Platform for Real‑Time RPC Visibility

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.

KafkaMonitoringRPC
0 likes · 10 min read
Overwatch: A Distributed System Monitoring Platform for Real‑Time RPC Visibility
Architecture Digest
Architecture Digest
Apr 4, 2016 · Backend Development

Handling Distributed Transactions in Large‑Scale Microservice Systems

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.

Microservicescqrsdistributed transactions
0 likes · 8 min read
Handling Distributed Transactions in Large‑Scale Microservice Systems
ITPUB
ITPUB
Feb 19, 2016 · Backend Development

Rethinking 12306 Ticketing: A Domain‑Driven Design Model for High‑Concurrency Reservations

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.

Domain-Driven Designconcurrencycqrs
0 likes · 25 min read
Rethinking 12306 Ticketing: A Domain‑Driven Design Model for High‑Concurrency Reservations
21CTO
21CTO
Feb 16, 2016 · Backend Development

Rethinking 12306 Ticketing: A Domain‑Driven Design Model for Complex Train Reservations

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.

Backend ArchitectureDDDDomain-Driven Design
0 likes · 25 min read
Rethinking 12306 Ticketing: A Domain‑Driven Design Model for Complex Train Reservations
Qunar Tech Salon
Qunar Tech Salon
May 17, 2015 · Fundamentals

Why CQRS Is Becoming a Practical Architecture for Complex Business Applications

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.

Read-Write Separationcqrsdomain-driven design
0 likes · 5 min read
Why CQRS Is Becoming a Practical Architecture for Complex Business Applications