BestHub
Sign in
Tagged articles

cqrs

144 articles · Page 1 of 2
Ray's Galactic Tech
Ray's Galactic Tech
Aug 13, 2026 · Backend Development

Event Sourcing Primer: Rebuilding State Without a Database

This article explains how event sourcing replaces the traditional current‑state table with an immutable event log, allowing systems to reconstruct any state, handle concurrency, support auditing, and power flexible read models through projections, while outlining the necessary architectural components such as aggregates, event stores, snapshots, outbox, idempotency, and the natural transition to CQRS.

Backend ArchitectureIdempotencycqrs
0 likes · 32 min read
Event Sourcing Primer: Rebuilding State Without a Database
Ray's Galactic Tech
Ray's Galactic Tech
Aug 11, 2026 · Backend Development

Why the User Model in Orders Slows Microservices – DDD Context Demo in Java

The article explains how sharing the full User model inside the Order aggregate creates hidden coupling that blows up microservice performance, and shows a step‑by‑step DDD bounded‑context refactor with event‑storming, outbox, saga, idempotency and CQRS using Java 21, Spring Boot 3.x, MySQL and Kafka.

DDDKafkaMicroservices
0 likes · 35 min read
Why the User Model in Orders Slows Microservices – DDD Context Demo in Java
webdream
webdream
Jul 18, 2026 · Backend Development

Java Architecture Overview: 7 Key Patterns from Layered to DDD

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.

Clean ArchitectureDomain-Driven Designarchitecture
0 likes · 11 min read
Java Architecture Overview: 7 Key Patterns from Layered to DDD
Yumin Fish Harvest
Yumin Fish Harvest
Jul 14, 2026 · Backend Development

Mastering CQRS: When to Separate Read and Write in DDD

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.

Backend ArchitectureCommand Query SeparationDomain-Driven Design
0 likes · 26 min read
Mastering CQRS: When to Separate Read and Write in DDD
Architectural Methodology
Architectural Methodology
Jul 3, 2026 · Fundamentals

From DDD’s Four‑Layer Model to Clean Architecture: Tracing the Evolution of Layered Design

The article examines how software architecture has progressed from the traditional DDD four‑layer structure through Hexagonal, Onion, and Clean architectures, explaining essential versus accidental complexity, layering principles, dependency inversion, and how each pattern refines modularity, testability, and dependency direction.

Clean ArchitectureDDDOnion Architecture
0 likes · 12 min read
From DDD’s Four‑Layer Model to Clean Architecture: Tracing the Evolution of Layered Design
webdream
webdream
Jun 24, 2026 · Backend Development

Combine or Split Endorsement and Policy? Microservice for Life‑Insurance

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.

Domain-Driven DesignMicroservicescqrs
0 likes · 11 min read
Combine or Split Endorsement and Policy? Microservice for Life‑Insurance
ZhiKe AI
ZhiKe AI
Jun 7, 2026 · Backend Development

Why Event Sourcing Rebuilds State from an Event Sequence

The article explains how Event Sourcing stores immutable, ordered events instead of the current state, details aggregate rehydration, snapshots, and projections, clarifies its orthogonal relationship with CQRS and DDD, and debunks four common misconceptions about the pattern.

Backend ArchitectureDDDProjections
0 likes · 13 min read
Why Event Sourcing Rebuilds State from an Event Sequence
ZhiKe AI
ZhiKe AI
Jun 6, 2026 · Backend Development

Why CQRS Is More Than Just Read‑Write Separation

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.

CQSCommand Query SeparationDDD
0 likes · 13 min read
Why CQRS Is More Than Just Read‑Write Separation
AI Skills Research
AI Skills Research
Jun 2, 2026 · Backend Development

Two Common CQRS Design Approaches and How to Choose the Right One

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.

Domain-Driven Designarchitecturecqrs
0 likes · 7 min read
Two Common CQRS Design Approaches and How to Choose the Right One
LuTiao Programming
LuTiao Programming
May 21, 2026 · Backend Development

Stop Fighting Microservice Calls—Why Experts Prefer Event‑Driven Architecture for Decoupling Distributed Systems

The article explains how traditional synchronous microservice calls create tight coupling, cascading failures, scaling bottlenecks, and high latency, and demonstrates that adopting an event‑driven architecture with producers, consumers, and a message broker such as Kafka can fully decouple services, improve scalability, and enable patterns like event sourcing and CQRS.

KafkaMessage BrokerMicroservices
0 likes · 14 min read
Stop Fighting Microservice Calls—Why Experts Prefer Event‑Driven Architecture for Decoupling Distributed Systems
Architecture Digest
Architecture Digest
May 15, 2026 · Databases

Why Alibaba Bans Joins Over Three Tables – A Must‑Know Rule for SQL Engineers

Alibaba’s Java Development Manual mandates that any SQL involving more than three tables must be avoided, a rule that stems from the exponential cost of multi‑table joins in a single‑instance database, prompting engineers to rethink data modeling, adopt denormalization, wide tables, materialized views, CQRS or application‑level assembly instead of relying on complex joins.

AlibabaDatabase DesignJOIN
0 likes · 12 min read
Why Alibaba Bans Joins Over Three Tables – A Must‑Know Rule for SQL Engineers
samdeepthink
samdeepthink
May 12, 2026 · Backend Development

Three Years of DDD in Practice: Insights from the Opening Chapter

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.

AggregatesBounded ContextDomain-Driven Design
0 likes · 8 min read
Three Years of DDD in Practice: Insights from the Opening Chapter
ITPUB
ITPUB
Mar 7, 2026 · Backend Development

Transform Messy Code with DDD + CQRS: A Practical Guide for Clean Architecture

Learn how to break the cycle of unreadable, tangled code by applying Domain-Driven Design and Command-Query Responsibility Segregation, with concrete examples, step-by-step refactoring, architecture diagrams, code snippets, and practical tips for gradually adopting these patterns in real-world backend projects.

DDDDomain modelingMicroservices
0 likes · 16 min read
Transform Messy Code with DDD + CQRS: A Practical Guide for Clean Architecture
Java Tech Enthusiast
Java Tech Enthusiast
Feb 13, 2026 · Backend Development

How DDD + CQRS Can Turn Chaotic Java Code into Clean, Scalable Architecture

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.

DDDDomain-Driven Designcqrs
0 likes · 14 min read
How DDD + CQRS Can Turn Chaotic Java Code into Clean, Scalable Architecture
Rare Earth Juejin Tech Community
Rare Earth Juejin Tech Community
Nov 9, 2025 · Backend Development

Why I Stopped Using DDD: Real‑World Pain Points and Lessons Learned

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.

DDDDomain-Driven Designcqrs
0 likes · 25 min read
Why I Stopped Using DDD: Real‑World Pain Points and Lessons Learned
ITFLY8 Architecture Home
ITFLY8 Architecture Home
Jun 6, 2025 · Backend Development

How to Split Services Effectively: Principles, Real Cases, and Domain Modeling

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.

Domain-Driven DesignMicroservicesService Splitting
0 likes · 6 min read
How to Split Services Effectively: Principles, Real Cases, and Domain Modeling
Code Ape Tech Column
Code Ape Tech Column
May 19, 2025 · Backend Development

Mastering CQRS in Spring Microservices: From Basics to Event Sourcing

This article explains the CQRS architectural pattern, its benefits and pitfalls, and provides a step‑by‑step guide to implementing CQRS with Spring Boot, Axon, and Kafka, including command and query handling, event sourcing, and practical considerations for microservice architectures.

AxonBackend ArchitectureKafka
0 likes · 13 min read
Mastering CQRS in Spring Microservices: From Basics to Event Sourcing
Code Ape Tech Column
Code Ape Tech Column
Mar 3, 2025 · Backend Development

Understanding CQRS and Implementing It with Spring Microservices

This article explains the CQRS pattern, its origins, benefits, and challenges, and provides a step‑by‑step guide with Java code examples on how to implement CQRS, event sourcing, and asynchronous communication using Spring Boot, Axon, and Kafka in microservice architectures.

Spring Bootcqrsevent sourcing
0 likes · 12 min read
Understanding CQRS and Implementing It with Spring Microservices
37 Interactive Technology Team
37 Interactive Technology Team
Feb 19, 2025 · Fundamentals

Domain-Driven Design (DDD) and Microservice Architecture: Concepts, Patterns, and Refactoring Strategies

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.

Bounded ContextDomain-Driven Designcqrs
0 likes · 9 min read
Domain-Driven Design (DDD) and Microservice Architecture: Concepts, Patterns, and Refactoring Strategies
Senior Tony
Senior Tony
Oct 12, 2024 · Backend Development

When Monolith Meets Microservices: API Composition vs CQRS for Complex Queries

This article compares API composition and CQRS patterns for handling distributed queries in evolving monolithic systems, illustrating their workflows with e‑commerce and online‑education examples, discussing performance trade‑offs, implementation details using Canal and ElasticSearch, and offering practical guidance on when to adopt each approach.

API compositionBackend ArchitectureCanal
0 likes · 8 min read
When Monolith Meets Microservices: API Composition vs CQRS for Complex Queries
IT Architects Alliance
IT Architects Alliance
Sep 29, 2024 · Backend Development

Event-Driven Architecture: Core Concepts, Design Principles, and Practical Practices

This article explains the fundamentals of Event‑Driven Architecture, covering its core components, design principles such as event granularity and immutability, practical implementation steps, common use cases, and the challenges developers face when building loosely coupled, high‑response distributed systems.

cqrsevent-drivenevent-sourcing
0 likes · 9 min read
Event-Driven Architecture: Core Concepts, Design Principles, and Practical Practices
JavaEdge
JavaEdge
Aug 18, 2024 · Backend Development

When Should You Use Fine‑Grained vs Coarse‑Grained Resources in REST APIs?

This article explains how to choose between fine‑grained and coarse‑grained resource designs in REST APIs, illustrating trade‑offs with blog‑post examples, showing how to model business processes as intent resources, and discussing the impact of avoiding PUT in favor of CQRS.

API DesignCRUDREST
0 likes · 23 min read
When Should You Use Fine‑Grained vs Coarse‑Grained Resources in REST APIs?
Wukong Talks Architecture
Wukong Talks Architecture
May 23, 2024 · Backend Development

Key Design Principles for High‑Concurrency Architecture and Read/Write Separation

This article explains the essential conditions, metrics, and scenario classifications for building high‑concurrency systems, then details common solutions such as database read/write separation, local and distributed caching, cache‑eviction policies, handling master‑slave lag, preventing cache penetration and avalanche, and applying CQRS to achieve scalable, high‑performance back‑end services.

Databasecachingcqrs
0 likes · 21 min read
Key Design Principles for High‑Concurrency Architecture and Read/Write Separation
Programmer DD
Programmer DD
May 23, 2024 · Backend Development

Mastering High‑Concurrency Architecture: From Metrics to Read/Write Splitting and Caching

This article explains the essential elements of high‑concurrency system design—performance, availability, scalability—introduces quantitative metrics, classifies read‑heavy and write‑heavy scenarios, and details practical solutions such as database read/write separation, local and distributed caching, cache‑penetration and avalanche mitigation, and CQRS implementation for billion‑user applications.

Database ReplicationRediscaching
0 likes · 22 min read
Mastering High‑Concurrency Architecture: From Metrics to Read/Write Splitting and Caching
macrozheng
macrozheng
Apr 16, 2024 · Backend Development

Boost Java Backend Development with DDD, CQRS, and Automated Maven Archetype Generation

This article explains how to lower the learning curve of DDD and CQRS by using structured, standardized, and templated approaches, introduces a Maven archetype for rapid project scaffolding, and demonstrates an IntelliJ IDEA plugin that auto‑generates boilerplate code for aggregate roots, commands, queries, and related components.

DDDMavenSpringBoot
0 likes · 16 min read
Boost Java Backend Development with DDD, CQRS, and Automated Maven Archetype Generation
dbaplus Community
dbaplus Community
Mar 25, 2024 · Backend Development

Why CQRS Matters: Reducing System Complexity Through Command‑Query Separation

This article explains how applying CQRS and layered splitting—separating commands and queries across service, model, repository, and data layers—can dramatically lower system complexity, improve performance, and resolve common conflicts in high‑traffic backend applications.

Command Query SeparationDomain-Driven Designcqrs
0 likes · 12 min read
Why CQRS Matters: Reducing System Complexity Through Command‑Query Separation
Efficient Ops
Efficient Ops
Jan 8, 2024 · Databases

Eight Proven Strategies to Supercharge Database Performance

This article outlines why databases become slow, introduces a four‑layer optimization framework, and presents eight practical solutions—including data reduction, archiving, sharding, caching, and read‑replica strategies—to help engineers systematically diagnose and resolve the majority of performance bottlenecks.

Data ArchivingNoSQLSharding
0 likes · 20 min read
Eight Proven Strategies to Supercharge Database Performance
DaTaobao Tech
DaTaobao Tech
Jan 8, 2024 · Fundamentals

Understanding Application Architecture: From Chaos to Order

Understanding an application's architecture—defining clear module and package hierarchies, adopting layered patterns like Hexagonal or Clean Architecture, and applying principles such as Dependency Inversion and CQRS—transforms chaotic codebases into maintainable, testable systems that reduce onboarding time and simplify future development.

Dependency InversionDomain-Driven DesignModule Design
0 likes · 22 min read
Understanding Application Architecture: From Chaos to Order
Code Ape Tech Column
Code Ape Tech Column
Dec 26, 2023 · Databases

Eight Major Database Optimization Strategies for Backend Engineers

This article outlines eight comprehensive database optimization approaches—reducing data volume, using space for performance, selecting appropriate storage systems, and related techniques such as data archiving, intermediate tables, serialization, sharding, distributed caching, read‑write splitting, and CQRS—to help backend engineers systematically address common performance bottlenecks.

Shardingbackend engineeringcqrs
0 likes · 23 min read
Eight Major Database Optimization Strategies for Backend Engineers
IT Xianyu
IT Xianyu
Dec 16, 2023 · Backend Development

Understanding CQRS and Event Sourcing with Spring Microservices

This article explains the CQRS pattern, its origins, benefits, and pitfalls, then details how to implement CQRS and event sourcing in Spring‑based microservices using Axon and Kafka, while discussing architectural considerations, scalability, consistency, and tooling.

AxonKafkaMicroservices
0 likes · 12 min read
Understanding CQRS and Event Sourcing with Spring Microservices
Code Ape Tech Column
Code Ape Tech Column
Nov 28, 2023 · Backend Development

Understanding CQRS and Implementing It with Spring Microservices

This article explains the CQRS architectural pattern, its benefits and challenges, and provides a step‑by‑step guide to implementing CQRS, event sourcing, and asynchronous communication with Spring Boot, Axon, and Apache Kafka in microservice environments.

MicroservicesSpring Bootcqrs
0 likes · 13 min read
Understanding CQRS and Implementing It with Spring Microservices
JD Retail Technology
JD Retail Technology
Nov 24, 2023 · Backend Development

Practical Experience and Technical Solutions for DDD, Clean Architecture, CQRS, and Saga in Backend Development

This article shares practical experiences and detailed technical solutions for applying Domain‑Driven Design, Clean (Onion) Architecture, CQRS, and Saga patterns in backend systems, covering theory recap, modeling methods, module separation, code examples, and distributed transaction strategies.

Clean ArchitectureDDDSAGA
0 likes · 28 min read
Practical Experience and Technical Solutions for DDD, Clean Architecture, CQRS, and Saga in Backend Development
Architect
Architect
Oct 23, 2023 · Backend Development

Designing a High‑Performance Asynchronous Event System for Video Likes Using CQRS, Kafka, and Multi‑Level Caching

This article walks through the evolution of a video‑like service from a simple database‑centric design to a robust, CQRS‑based, Kafka‑driven asynchronous architecture that tackles CPU bottlenecks, connection limits, duplicate consumption, scaling, flow‑control, hotspot isolation, error retry, and MQ failure while providing a unified messaging platform.

Async Processingcqrsscalability
0 likes · 20 min read
Designing a High‑Performance Asynchronous Event System for Video Likes Using CQRS, Kafka, and Multi‑Level Caching
Bilibili Tech
Bilibili Tech
Sep 26, 2023 · Backend Development

Applying CQRS Architecture to Live Streaming Room Service: Design, Evolution, and Operational Practices

The live‑streaming room service was re‑architected using CQRS, dividing read‑heavy viewer functions from write‑intensive broadcaster operations, splitting the monolith into focused Go micro‑services, adding multi‑level caching, event‑driven sync, extensive observability, and automated incident‑response to achieve massive scalability and rapid fault recovery.

cqrslive streamingobservability
0 likes · 18 min read
Applying CQRS Architecture to Live Streaming Room Service: Design, Evolution, and Operational Practices
AI Skills Research
AI Skills Research
Aug 12, 2023 · Backend Development

Implementing CQRS with MediatR – Part 1

This article explains the CQRS and Mediator patterns, compares CQRS to CRUD, discusses trade‑offs, and provides a step‑by‑step guide to configuring MediatR in an ASP.NET Core Web API, creating commands, queries, handlers, and testing the setup with Postman.

ASP.NET CoreCommandMediatR
0 likes · 12 min read
Implementing CQRS with MediatR – Part 1
Bilibili Tech
Bilibili Tech
Aug 11, 2023 · Backend Development

Designing a High‑Performance Asynchronous Event System for Bilibili’s Like Service

Bilibili’s railgun platform transforms its high‑traffic like service into a scalable, fault‑tolerant system by moving writes to an asynchronous, Kafka‑driven pipeline, applying CQRS, partitioned processing, idempotency, hot‑key isolation, rate‑limiting, and unified SDKs, dramatically reducing database load and achieving ten‑fold throughput gains.

AsynchronousKafkabackend
0 likes · 21 min read
Designing a High‑Performance Asynchronous Event System for Bilibili’s Like Service
Code Ape Tech Column
Code Ape Tech Column
Jul 12, 2023 · Backend Development

Microservice Architecture Design Patterns: Advantages, Disadvantages, and When to Use Them

This article provides a comprehensive overview of microservice architecture, detailing its core concepts, key characteristics, benefits and drawbacks, and presents 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—along with their pros, cons, usage scenarios, and technology examples.

Backend Architecturecircuit breakercqrs
0 likes · 41 min read
Microservice Architecture Design Patterns: Advantages, Disadvantages, and When to Use Them
Architects Research Society
Architects Research Society
Jul 5, 2023 · Fundamentals

Domain-Driven Design and Its Relationship with Redux

This article explains the core concepts of Domain‑Driven Design, distinguishes its strategic and tactical patterns, and shows how Redux implements similar ideas such as queries, commands, domain events, and aggregates, while also discussing event sourcing, CQRS, and code examples for decoupling.

Domain-Driven DesignReduxcqrs
0 likes · 12 min read
Domain-Driven Design and Its Relationship with Redux
Architects Research Society
Architects Research Society
Jun 20, 2023 · Backend Development

Designing Microservice Architecture: Patterns, Principles, and Best Practices

This article guides readers through the evolution from monolithic to event‑driven microservice architectures, covering design patterns, scalability, reliability, communication strategies such as API gateways, BFF, service aggregation, asynchronous messaging, CQRS, event sourcing, and technology choices like Kafka and RabbitMQ to build highly available, scalable, and maintainable systems.

API GatewayDesign PatternsMicroservices
0 likes · 24 min read
Designing Microservice Architecture: Patterns, Principles, and Best Practices
ITPUB
ITPUB
Jun 1, 2023 · Backend Development

Mastering DDD: Layered Architecture, Context Integration, and CQRS Explained

This article walks through the essential concepts of Domain‑Driven Design, detailing a layered architecture, practical code organization, integration techniques such as Open Host Service and Anticorruption Layers, and a concise introduction to CQRS for handling complex queries efficiently.

Context IntegrationDomain-Driven Designcqrs
0 likes · 18 min read
Mastering DDD: Layered Architecture, Context Integration, and CQRS Explained
Code Ape Tech Column
Code Ape Tech Column
May 4, 2023 · Backend Development

Practical Application of Domain‑Driven Design (DDD) in an Internal Trading Center Microservice

This article explains how the author applied Domain‑Driven Design to build a microservice for an internal trading center, reviewing DDD strategic and tactical design, various architecture layer theories, a customized layered architecture, Maven module structure, and detailed responsibilities of each layer while sharing practical tips and challenges.

Clean ArchitectureDDDMicroservices
0 likes · 16 min read
Practical Application of Domain‑Driven Design (DDD) in an Internal Trading Center Microservice
Architects Research Society
Architects Research Society
Apr 18, 2023 · Backend Development

Event Sourcing, CQRS, and Stream Processing with Apache Kafka

Event sourcing models state changes as immutable logs, and when combined with CQRS and Kafka Streams, it enables scalable, fault‑tolerant architectures where write and read paths are decoupled, supporting local or external state stores, interactive queries, and zero‑downtime upgrades.

Backend ArchitectureStream Processingcqrs
0 likes · 21 min read
Event Sourcing, CQRS, and Stream Processing with Apache Kafka
Alibaba Cloud Developer
Alibaba Cloud Developer
Apr 4, 2023 · Fundamentals

Why Solving Business Problems Is the True Role of Engineers – A Deep Dive into DDD

This article explains that an engineer's primary responsibility is to solve business problems, explores the challenges across a product's lifecycle, outlines software complexity dimensions, and demonstrates how Domain‑Driven Design, strategic and tactical patterns, and modern architectural styles like Hexagonal and CQRS can effectively manage that complexity.

complexity managementcqrshexagonal-architecture
0 likes · 31 min read
Why Solving Business Problems Is the True Role of Engineers – A Deep Dive into DDD
Architects Research Society
Architects Research Society
Feb 28, 2023 · Backend Development

Event Sourcing, CQRS, and Stream Processing with Apache Kafka

This article explains how event sourcing models state changes as immutable logs, discusses the trade‑offs of the pattern, and shows how Apache Kafka and Kafka Streams enable CQRS and interactive queries for building scalable, resilient backend applications.

Backend Architecturecqrsevent sourcing
0 likes · 20 min read
Event Sourcing, CQRS, and Stream Processing with Apache Kafka
Architect's Journey
Architect's Journey
Feb 15, 2023 · Backend Development

How to Successfully Land DDD: A Practical Engineering Walkthrough

This article walks through the author’s two‑year experience applying Domain‑Driven Design to payment, settlement and fund services, explains strategic vs tactical design, compares classic DDD layers, Clean, Hexagonal and Diamond architectures, details module organization, CQRS, and shares practical pros, cons and implementation tips.

Clean ArchitectureDDDDomain-Driven Design
0 likes · 22 min read
How to Successfully Land DDD: A Practical Engineering Walkthrough
政采云技术
政采云技术
Feb 14, 2023 · Frontend Development

Analysis of Remesh: A Frontend DDD Framework

This article provides an in-depth analysis of Remesh, a frontend framework implementing Domain-Driven Design (DDD) principles, exploring its core concepts, advantages, and practical implementation.

Code OrganizationDDDDomain-Driven Design
0 likes · 13 min read
Analysis of Remesh: A Frontend DDD Framework
Code Ape Tech Column
Code Ape Tech Column
Jan 5, 2023 · Databases

Eight Database Optimization Strategies for Backend Engineers

This article outlines eight comprehensive database optimization techniques—including reducing data volume, using space‑for‑performance methods, and selecting appropriate storage systems—explaining their underlying principles, trade‑offs, and practical implementation steps for backend engineers facing slow queries and high load.

NoSQLbackend engineeringcqrs
0 likes · 19 min read
Eight Database Optimization Strategies for Backend Engineers
High Availability Architecture
High Availability Architecture
Dec 19, 2022 · Backend Development

Applying Domain-Driven Design (DDD) to a Live E‑Commerce Service: Concepts, Architecture, and Practice

This article explains how a WeChat team used Domain‑Driven Design to improve the maintainability, scalability, and stability of a fast‑paced, multi‑team e‑commerce project, covering strategic and tactical modeling, layered architecture, subdomains, bounded contexts, anti‑corruption layers, domain events, aggregates, repositories, and a practical code scaffold with C++ examples.

DDDDomain-Driven DesignMicroservices
0 likes · 18 min read
Applying Domain-Driven Design (DDD) to a Live E‑Commerce Service: Concepts, Architecture, and Practice
Tencent Cloud Developer
Tencent Cloud Developer
Dec 8, 2022 · Backend Development

Applying Domain-Driven Design (DDD) in a High‑Throughput E‑Commerce System: Concepts, Layers, and Practical Code

The article explains how a WeChat e‑commerce team adopted Domain‑Driven Design, reorganizing a fast‑paced, multi‑team project into a four‑layer onion architecture with strategic sub‑domains, bounded contexts, anti‑corruption layers, domain events, aggregates, repositories and services, to achieve maintainability, extensibility, cohesion and loose coupling.

C++DDDDomain-Driven Design
0 likes · 21 min read
Applying Domain-Driven Design (DDD) in a High‑Throughput E‑Commerce System: Concepts, Layers, and Practical Code
Top Architect
Top Architect
Oct 21, 2022 · Backend Development

From Monolithic to Distributed Architecture: A Detailed Inventory System Case Study

This article explains the concepts of software architecture, compares monolithic and distributed styles, and walks through a real‑world inventory system migration—including functional and business splitting, CQRS adoption, and distributed transaction challenges—illustrated with Java code examples.

architecturecqrsdistributed systems
0 likes · 17 min read
From Monolithic to Distributed Architecture: A Detailed Inventory System Case Study
Programmer DD
Programmer DD
Oct 12, 2022 · Backend Development

From Monolith to Distributed: How We Transformed a Stock System with CQRS

This article explains what software architecture is, why choosing an architectural style matters, compares monolithic and distributed approaches using a real‑world inventory system case study, and details the step‑by‑step functional and business splitting, CQRS implementation, code refactoring, and handling of distributed transactions.

Microservicescqrsdistributed systems
0 likes · 20 min read
From Monolith to Distributed: How We Transformed a Stock System with CQRS
Top Architect
Top Architect
Sep 21, 2022 · Fundamentals

Understanding Software Architecture: Principles, Patterns, and the COLA Framework

This article explains the concept of software architecture, why it is essential, the responsibilities of architects, various architectural classifications, and introduces classic patterns such as layered, CQRS, hexagonal, onion, and the open‑source COLA framework with its design, extension, and specification guidelines.

COLA frameworkOnion Architecturecqrs
0 likes · 16 min read
Understanding Software Architecture: Principles, Patterns, and the COLA Framework
dbaplus Community
dbaplus Community
Sep 11, 2022 · Backend Development

Refactoring a Monolithic Inventory System to Distributed Microservices with CQRS

Facing rapid growth and stability issues, the team transformed a monolithic inventory platform into a distributed microservice architecture, employing functional and business decomposition, CQRS principles, and careful code refactoring to improve availability, scalability, and maintainability while addressing challenges like distributed transactions and data consistency.

Microservicesarchitecturecqrs
0 likes · 18 min read
Refactoring a Monolithic Inventory System to Distributed Microservices with CQRS
Code Ape Tech Column
Code Ape Tech Column
Sep 5, 2022 · Backend Development

Microservice Architecture Design Patterns: Benefits, Drawbacks, and Usage Guidelines

This article explains microservice architecture, outlines its key characteristics, advantages and disadvantages, and presents 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—along with their pros, cons, appropriate scenarios, and technology examples.

Backend ArchitectureDesign Patternscqrs
0 likes · 28 min read
Microservice Architecture Design Patterns: Benefits, Drawbacks, and Usage Guidelines
Architecture Digest
Architecture Digest
Aug 18, 2022 · Backend Development

From Monolith to CQRS: An Evolutionary Guide to Read‑Write Separation

This article walks through the progressive evolution of a software system—from a traditional monolithic architecture to a task‑oriented monolith, then to Command‑Query Separation (CQS) and finally to a full CQRS solution—explaining the motivations, trade‑offs, and techniques such as eventual consistency, event sourcing, and read‑model generation.

Read-Write Separationcqrssoftware architecture
0 likes · 11 min read
From Monolith to CQRS: An Evolutionary Guide to Read‑Write Separation
IT Architects Alliance
IT Architects Alliance
Aug 7, 2022 · Backend Development

Why CQRS Matters: Evolving Monoliths into Scalable Systems

This article walks through the evolution from a traditional monolithic architecture to a CQRS‑based design, explaining the motivations, trade‑offs, and concrete techniques such as read‑write separation, message‑driven commands, eventual consistency, and event sourcing for building more scalable and maintainable systems.

CQSDDDRead-Write Separation
0 likes · 12 min read
Why CQRS Matters: Evolving Monoliths into Scalable Systems
ITFLY8 Architecture Home
ITFLY8 Architecture Home
Aug 6, 2022 · Backend Development

Why CQRS Matters: Evolving From Monolithic to Scalable Architecture

This article walks through the evolution of software design from a traditional monolithic API server to a CQRS-based architecture, highlighting the drawbacks of the anemic CRUD model, the benefits of read/write separation, domain messaging, eventual consistency, and practical implementation considerations.

DDDRead-Write Separationbackend development
0 likes · 9 min read
Why CQRS Matters: Evolving From Monolithic to Scalable Architecture
Code Ape Tech Column
Code Ape Tech Column
Jul 25, 2022 · Databases

Eight Database Optimization Strategies: Reducing Data Volume, Leveraging Space, and Selecting the Right Storage System

This article presents a systematic guide for backend engineers on diagnosing why databases become slow and offers eight practical optimization solutions—including data reduction, space‑for‑performance techniques, and appropriate storage system choices—organized by the layer of the stack they target.

NoSQLcqrsdata reduction
0 likes · 20 min read
Eight Database Optimization Strategies: Reducing Data Volume, Leveraging Space, and Selecting the Right Storage System
IT Architects Alliance
IT Architects Alliance
Jun 8, 2022 · Backend Development

Mastering Microservice Patterns: From Decomposition to Resilience

This article provides a comprehensive overview of common microservice patterns and design principles, covering goals such as cost reduction, faster releases, resilience, visibility, and detailing decomposition, integration, database, CQRS, observability, health‑check, and deployment strategies for building robust backend systems.

API GatewayBlue-Green DeploymentDesign Patterns
0 likes · 20 min read
Mastering Microservice Patterns: From Decomposition to Resilience
IT Architects Alliance
IT Architects Alliance
Jun 6, 2022 · Backend Development

From Monolith to Event‑Driven Microservices: A Step‑by‑Step Architecture Blueprint

This comprehensive guide explains how to transform a small e‑commerce monolith into a highly scalable, low‑latency, fault‑tolerant event‑driven microservice system by applying layered architecture, SOA, design patterns, API‑gateway strategies, CQRS, event sourcing, and appropriate cloud‑native technologies.

API GatewayDesign PatternsMicroservices
0 likes · 22 min read
From Monolith to Event‑Driven Microservices: A Step‑by‑Step Architecture Blueprint
Selected Java Interview Questions
Selected Java Interview Questions
May 6, 2022 · Databases

Eight Database Optimization Strategies for Performance Improvement

This article presents a systematic overview of eight practical database optimization techniques—including data reduction, serialization, archiving, intermediate tables, sharding, distributed caching, master‑slave replication, and appropriate storage selection—to help backend engineers diagnose and resolve the majority of performance bottlenecks caused by data volume, high load, and search complexity.

Data ArchivingNoSQLcaching
0 likes · 19 min read
Eight Database Optimization Strategies for Performance Improvement
Java Backend Technology
Java Backend Technology
May 1, 2022 · Databases

Mastering Database Performance: 8 Proven Optimization Strategies

This article explains why databases become slow, introduces a four‑layer thinking model, and presents eight practical solutions—including reducing data volume, leveraging space for performance, and selecting the right storage system—to help backend engineers resolve 80‑90% of common performance problems.

Data ArchivingNoSQLSharding
0 likes · 19 min read
Mastering Database Performance: 8 Proven Optimization Strategies
dbaplus Community
dbaplus Community
Apr 24, 2022 · Databases

Eight Practical Strategies to Tackle Database Performance Bottlenecks

This article outlines a systematic approach for backend engineers to identify root causes of database slowness and presents eight concrete optimization techniques—ranging from data reduction and space‑for‑performance trade‑offs to appropriate storage system selection—while explaining when each method is most effective and what trade‑offs to consider.

Database PerformanceNoSQLOptimization
0 likes · 18 min read
Eight Practical Strategies to Tackle Database Performance Bottlenecks
ITPUB
ITPUB
Apr 14, 2022 · Databases

Eight Proven Strategies to Supercharge Database Performance

This article explains why databases become slow, introduces a four‑layer thinking model, and presents eight practical optimization techniques—including data reduction, caching, sharding, master‑slave replication, and CQRS—along with their benefits, drawbacks, and suitable scenarios.

NoSQLShardingcaching
0 likes · 22 min read
Eight Proven Strategies to Supercharge Database Performance
Architects Research Society
Architects Research Society
Apr 8, 2022 · Backend Development

Top Microservices Design Patterns for Building Applications

This article explains microservices fundamentals, outlines key design principles, and details ten essential design patterns—including Aggregator, API Gateway, Chain of Responsibility, Asynchronous Messaging, Shared Database, Event Sourcing, Branch, CQRS, Circuit Breaker, and Decomposition—to help developers build scalable, resilient applications.

API GatewayBackend ArchitectureDesign Patterns
0 likes · 15 min read
Top Microservices Design Patterns for Building Applications
IT Architects Alliance
IT Architects Alliance
Mar 30, 2022 · Backend Development

Designing a Scalable Event-Driven Microservices Architecture for E‑Commerce

This article guides readers through the evolution from a monolithic e‑commerce application to a highly available, scalable, low‑latency event‑driven microservices architecture, covering design patterns, principles, API gateway, BFF, service aggregation, CQRS, event sourcing, and technology stack choices such as Kafka and Cassandra.

KafkaMicroservicesarchitecture
0 likes · 21 min read
Designing a Scalable Event-Driven Microservices Architecture for E‑Commerce
Architects Research Society
Architects Research Society
Mar 29, 2022 · Backend Development

Designing Microservice Architecture with Patterns, Principles, and Best Practices

This comprehensive guide teaches how to design scalable, highly available microservice architectures by applying design patterns, principles, and best practices, covering the evolution from monolithic to event‑driven systems, communication strategies, data management techniques, and technology choices such as API gateways, BFF, CQRS, and Kafka.

API GatewayDesign Patternsarchitecture
0 likes · 23 min read
Designing Microservice Architecture with Patterns, Principles, and Best Practices
Qunar Tech Salon
Qunar Tech Salon
Mar 7, 2022 · Backend Development

High-Concurrency Flight Pricing System Design and Optimization at Qunar

This article details Qunar's high‑concurrency flight pricing architecture, covering the origin of pricing data, two‑level caching design, a cache‑management system, CQRS‑based policy storage, data compression techniques, and performance improvements achieved through these optimizations.

Backend Architecturecachingcqrs
0 likes · 20 min read
High-Concurrency Flight Pricing System Design and Optimization at Qunar
IT Architects Alliance
IT Architects Alliance
Feb 26, 2022 · Fundamentals

Why Clean Architecture, DDD, and CQRS Together Create Scalable, Testable Systems

This article explains Clean Architecture, shows how Domain‑Driven Design fits into its concentric‑layer model, and demonstrates how adding Command‑Query Responsibility Segregation (CQRS) enhances scalability, testability, and maintainability while outlining practical implementation steps, benefits, and trade‑offs.

Clean ArchitectureDesign PatternsDomain-Driven Design
0 likes · 22 min read
Why Clean Architecture, DDD, and CQRS Together Create Scalable, Testable Systems
High Availability Architecture
High Availability Architecture
Jan 20, 2022 · Backend Development

Event-Driven Architecture: Concepts, Scenarios, Patterns, and Practical Implementation

This article explains the fundamentals of event‑driven architecture, outlines when it should be used, describes common patterns such as event notification, state transfer, event sourcing, and CQRS, and provides a detailed example of applying these concepts in a content‑platform microservice system with code snippets and deployment considerations.

MicroservicesSoftware Designbackend
0 likes · 17 min read
Event-Driven Architecture: Concepts, Scenarios, Patterns, and Practical Implementation
vivo Internet Technology
vivo Internet Technology
Jan 19, 2022 · Backend Development

Event-Driven Architecture: Concepts, Scenarios, and Implementation Practices

Event‑driven architecture (EDA) coordinates micro‑services through immutable events and a reliable broker, enabling decoupling, asynchronous processing, and state‑change tracking via patterns such as event notification, state transfer, event sourcing, and CQRS, while offering scalability and robustness but demanding careful design to avoid complexity and consistency issues.

Message Queuebackend designcqrs
0 likes · 18 min read
Event-Driven Architecture: Concepts, Scenarios, and Implementation Practices
Top Architect
Top Architect
Dec 31, 2021 · Fundamentals

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

This article explains the fundamentals of software architecture, why it is needed, the responsibilities of architects, various architectural classifications, and introduces classic and modern application architectures such as layered, CQRS, hexagonal, onion, and the open‑source COLA framework with its design and extension principles.

COLADesign Patternscqrs
0 likes · 14 min read
Understanding Software Architecture: Concepts, Layers, and the COLA Framework
Top Architect
Top Architect
Nov 27, 2021 · Fundamentals

Understanding Software Architecture: From Basic Concepts to the COLA Framework

This article explains the fundamentals of software architecture, why architecture is needed, the responsibilities of architects, various architecture categories, common styles such as layered, CQRS, hexagonal and onion architectures, and introduces the open‑source COLA framework with its layered design, extension points and standards.

COLA frameworkDesign PatternsOnion Architecture
0 likes · 12 min read
Understanding Software Architecture: From Basic Concepts to the COLA Framework
IT Architects Alliance
IT Architects Alliance
Nov 24, 2021 · Fundamentals

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

This article explains the definition and purpose of software architecture, outlines various architectural classifications such as business, application, distributed, data, physical, and operational architectures, and introduces typical patterns like layered, CQRS, hexagonal, and onion architectures, culminating in a detailed overview of Alibaba's COLA application architecture and its design principles.

COLADesign Patternsapplication architecture
0 likes · 12 min read
Understanding Software Architecture: Concepts, Classifications, and the COLA Application Architecture
Architects' Tech Alliance
Architects' Tech Alliance
Nov 22, 2021 · Fundamentals

Understanding Software Architecture and the COLA Application Architecture

This article explains the concept of software architecture, its necessity, the role of architects, various architectural categories, typical patterns such as layered, CQRS, hexagonal and onion architectures, and introduces the COLA open‑source application architecture with its layered design, extension mechanisms, and specification guidelines.

COLAcqrsextension design
0 likes · 14 min read
Understanding Software Architecture and the COLA Application Architecture
Top Architect
Top Architect
Oct 17, 2021 · Cloud Native

How Redis Simplifies Microservice Design Patterns, Distributed Transactions, and Observability

This article explains how Redis can be used to implement and simplify a wide range of microservice design patterns—including bounded contexts, asynchronous messaging, orchestrated sagas, transaction inboxes, telemetry, event sourcing, CQRS, and shared data—while improving performance, scalability, and observability in cloud‑native architectures.

Cloud NativeMicroservicesRedis
0 likes · 16 min read
How Redis Simplifies Microservice Design Patterns, Distributed Transactions, and Observability
21CTO
21CTO
Oct 13, 2021 · Backend Development

When to Adopt CQRS? Balancing Read/Write Models for Scalable Backend Systems

This article examines the challenges of evolving data models in large applications, explains the Command Query Responsibility Segregation (CQRS) pattern, and outlines when to adopt or avoid it to balance read/write performance, scalability, and system complexity.

Backend ArchitectureData Modelingcqrs
0 likes · 11 min read
When to Adopt CQRS? Balancing Read/Write Models for Scalable Backend Systems
IT Architects Alliance
IT Architects Alliance
Oct 10, 2021 · Fundamentals

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

This article explains the definition and necessity of software architecture, outlines various architectural categories such as business, application, distributed, data, physical, and operations architectures, describes layered, CQRS, hexagonal and onion models, and introduces the COLA framework with its design principles and extension mechanisms.

COLADesign PatternsOnion Architecture
0 likes · 12 min read
Understanding Software Architecture: Concepts, Classifications, and the COLA Application Architecture
IT Architects Alliance
IT Architects Alliance
Aug 2, 2021 · R&D Management

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

This article explains the meaning of architecture, why it is essential for any system, the responsibilities of architects, various software architecture classifications, common patterns such as layered, CQRS, hexagonal and onion architectures, and introduces the open‑source COLA framework with its layered, extension, and standard design principles.

COLA frameworkOnion ArchitectureSystem Design
0 likes · 15 min read
What Is Software Architecture? Core Concepts, Patterns, and the COLA Framework
Java High-Performance Architecture
Java High-Performance Architecture
Jul 31, 2021 · Fundamentals

What Is Software Architecture? Core Concepts, Patterns, and Design Strategies

This article explains the definition of architecture, why it matters, the role of architects, various software architecture classifications, layered designs, and key patterns such as CQRS, hexagonal, onion, and the COLA framework, providing a comprehensive guide for building maintainable systems.

COLA frameworkOnion ArchitectureSystem Design
0 likes · 15 min read
What Is Software Architecture? Core Concepts, Patterns, and Design Strategies
IT Architects Alliance
IT Architects Alliance
Jul 24, 2021 · Fundamentals

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

This article explains what software architecture is, why it is needed, the responsibilities of architects, various classification types such as business, application, distributed, data, physical and operations, and introduces typical architectural styles like layered, CQRS, hexagonal, onion, and the open‑source COLA framework.

COLADesign PatternsOnion Architecture
0 likes · 13 min read
Understanding Software Architecture: Concepts, Classifications, and the COLA Framework
IT Architects Alliance
IT Architects Alliance
Jul 21, 2021 · Backend Development

Applying Domain‑Driven Design to Complex Business Systems: Strategies, Architecture, and Practices

The article explains how Domain‑Driven Design (DDD) helps tackle the growing complexity of business logic and technical requirements by separating concerns, using bounded contexts, layered and hexagonal architectures, and integrating with microservices, CQRS, and clean architecture to achieve scalable, maintainable, and adaptable systems.

Domain-Driven Designcqrs
0 likes · 39 min read
Applying Domain‑Driven Design to Complex Business Systems: Strategies, Architecture, and Practices
Java High-Performance Architecture
Java High-Performance Architecture
Jul 11, 2021 · Fundamentals

Why Domain‑Driven Design Is the Secret Weapon for Tackling Complex Business Systems

This article explains how Domain‑Driven Design (DDD) helps teams manage rising business and technical complexity by promoting a ubiquitous language, strategic and tactical design, layered and hexagonal architectures, and seamless integration with microservices, enabling rapid adaptation and robust, maintainable systems.

Domain-Driven DesignMicroservicescomplexity management
0 likes · 42 min read
Why Domain‑Driven Design Is the Secret Weapon for Tackling Complex Business Systems
21CTO
21CTO
Jul 9, 2021 · Backend Development

Top Microservice Design Patterns: Database per Service, Event Sourcing, CQRS, Saga

This article reviews essential microservice design patterns—including Database per Service, Event Sourcing, CQRS, Saga, Backend‑for‑Frontend, API Gateway, Strangler, Circuit Breaker, Externalized Configuration, and Consumer‑Driven Contract Testing—explaining their advantages, drawbacks, when to apply them, and common technology implementations.

API GatewayDesign PatternsMicroservices
0 likes · 28 min read
Top Microservice Design Patterns: Database per Service, Event Sourcing, CQRS, Saga
ITFLY8 Architecture Home
ITFLY8 Architecture Home
Jul 8, 2021 · Backend Development

Mastering Microservice Architecture: 10 Essential Design Patterns Explained

This comprehensive guide explores microservice architecture—from its historical roots and core characteristics to ten vital design patterns such as database per service, event sourcing, CQRS, Saga, BFF, API gateway, Strangler, circuit breaker, externalized configuration, and consumer‑driven contract testing—detailing their advantages, drawbacks, and practical usage scenarios.

API GatewayBackend ArchitectureDesign Patterns
0 likes · 28 min read
Mastering Microservice Architecture: 10 Essential Design Patterns Explained
Architecture Digest
Architecture Digest
Jul 4, 2021 · Fundamentals

Understanding Domain-Driven Design: Value, Process, and Architectural Practices

This article explains the principles and benefits of Domain-Driven Design (DDD), describing how strategic and tactical design, layered and hexagonal architectures, CQRS, and bounded contexts help manage complex business logic, improve scalability, and align software development with evolving business requirements.

Domain-Driven DesignMicroservicesStrategic Design
0 likes · 40 min read
Understanding Domain-Driven Design: Value, Process, and Architectural Practices
Java High-Performance Architecture
Java High-Performance Architecture
Jun 30, 2021 · Backend Development

Essential Microservice Design Patterns Every Backend Engineer Should Master

Explore key microservice design patterns—including Database per Service, Event Sourcing, CQRS, BFF, API Gateway, Strangler, Circuit Breaker, Externalized Configuration, and Consumer‑Driven Contract Testing—detailing their advantages, drawbacks, suitable scenarios, and technology examples to help architects build resilient, scalable backend systems.

cqrsdatabase per service
0 likes · 28 min read
Essential Microservice Design Patterns Every Backend Engineer Should Master
Architect's Journey
Architect's Journey
Jun 17, 2021 · Backend Development

Why You Lose to Product Managers: Master DDD Domain Modeling and Architecture

This article introduces Domain‑Driven Design, explains its strategic and tactical layers, walks through domain‑model discovery methods such as Event Storming and the Four‑Color model, details aggregate design, cross‑database query solutions, CQRS, Event Sourcing, and several clean‑architecture styles to help engineers build maintainable, business‑driven systems.

Clean ArchitectureDomain modelingDomain-Driven Design
0 likes · 15 min read
Why You Lose to Product Managers: Master DDD Domain Modeling and Architecture
Selected Java Interview Questions
Selected Java Interview Questions
Jun 17, 2021 · Backend Development

Design Patterns for Microservice Architecture

This article explains key microservice design patterns—including Database per Service, Event Sourcing, CQRS, BFF, API Gateway, Strangler, Circuit Breaker, Externalized Configuration, and Consumer‑Driven Contract Testing—detailing their advantages, disadvantages, suitable scenarios, and example technologies for building scalable, resilient backend systems.

Backend ArchitectureMicroservicesSAGA
0 likes · 26 min read
Design Patterns for Microservice Architecture
ITFLY8 Architecture Home
ITFLY8 Architecture Home
May 21, 2021 · Backend Development

When Should You Adopt CQRS? Balancing Read and Write Models for Scalable Systems

This article examines how evolving software requirements can lock systems into rigid data models, explains the Command Query Responsibility Segregation (CQRS) pattern, and outlines when CQRS is beneficial or detrimental, helping architects decide if separating read and write models will improve scalability and maintainability.

backend designcqrsread/write separation
0 likes · 8 min read
When Should You Adopt CQRS? Balancing Read and Write Models for Scalable Systems
IT Architects Alliance
IT Architects Alliance
May 16, 2021 · Fundamentals

Why Domain-Driven Design Is the Key to Taming Complex Business Logic

Domain-Driven Design (DDD) offers a systematic approach to separate business complexity from technical concerns, using ubiquitous language, bounded contexts, layered and hexagonal architectures, CQRS, and strategic and tactical patterns, enabling teams to build flexible, scalable systems that quickly adapt to evolving requirements.

Bounded ContextDomain-Driven DesignMicroservices
0 likes · 41 min read
Why Domain-Driven Design Is the Key to Taming Complex Business Logic
Java High-Performance Architecture
Java High-Performance Architecture
May 14, 2021 · Backend Development

Why CQRS? Unlocking Flexible Queries and Scalable Architecture

The article explains the CQRS (Command Query Responsibility Segregation) pattern, showing how separating command and query models addresses diverse data view needs, improves query flexibility, discusses synchronization methods, compares with microservices and caching, and outlines its benefits and trade‑offs.

Backend ArchitectureCommand Query Responsibility SegregationData Modeling
0 likes · 5 min read
Why CQRS? Unlocking Flexible Queries and Scalable Architecture
Top Architect
Top Architect
May 2, 2021 · Fundamentals

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

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.

AggregatesDomain modelingDomain-Driven Design
0 likes · 37 min read
Understanding Domain-Driven Design: Core Concepts, Layers, and Patterns