BestHub
Sign in
Tagged articles

Event Sourcing

79 articles · Page 1 of 1
Architect
Architect
Oct 1, 2026 · Artificial Intelligence

Pi vs DeepSeek Harness: Agent Loop Design for Continuation, Closure & Recovery

This article compares Pi and DeepSeek Harness agent loop architectures across four control points—input attribution, tool scheduling, closure permissions, and persistent evidence—revealing how each handles mid-task user constraints, parallel tool execution, token truncation, and crash recovery through distinct runtime contracts and durable extensions.

Agent ArchitectureAgent LoopCrash Recovery
0 likes · 20 min read
Pi vs DeepSeek Harness: Agent Loop Design for Continuation, Closure & Recovery
Code Farming
Code Farming
Sep 2, 2026 · Backend Development

Event Sourcing: Decouple Microservices with Domain Events

This article explains how event sourcing replaces synchronous call chains with domain events to decouple microservices, detailing the four core event elements, a three-step publish-subscribe flow using Spring Cloud Stream, and a practical template for implementation.

Domain EventsDomain-Driven DesignEvent Sourcing
0 likes · 6 min read
Event Sourcing: Decouple Microservices with Domain Events
Architects Research Society
Architects Research Society
Sep 1, 2026 · Operations

When Agents Vanish, Enterprise Work Must Persist: RHEOVELA’s Durable Process Model

RHEOVELA addresses the structural conflict that temporary AI agents cannot sustain long‑running enterprise tasks by persisting process instances through event sourcing, atomic idempotent command pipelines, and unified work items, ensuring reliable recovery, auditability, and continuity despite crashes, upgrades, or network failures.

Agent SystemsDurable WorkflowEvent Sourcing
0 likes · 5 min read
When Agents Vanish, Enterprise Work Must Persist: RHEOVELA’s Durable Process Model
Architecture and Beyond
Architecture and Beyond
Aug 30, 2026 · Artificial Intelligence

Agent Loop Termination: DeepSeek Harness vs Pi Architecture Deep Dive

This article compares how DeepSeek Harness and Pi determine when an agent loop ends, analyzing their multi-layer boundary models, state machines, turn/step debt tracking, stop hooks, tool conclusion semantics, cancellation handling, reason taxonomies, goal-driven outer loops, and the engineering trade-offs between a heavyweight event-sourced runtime and a lightweight embeddable kernel.

AI architectureAgent FrameworkAgent Loop
0 likes · 40 min read
Agent Loop Termination: DeepSeek Harness vs Pi Architecture Deep Dive
AndroidPub
AndroidPub
Aug 20, 2026 · Artificial Intelligence

How to Stop Large‑Model Coding Agents from Forgetting in Multi‑Turn Dialogues

The article explains why a coding agent may appear to forget earlier decisions, introduces a three‑layer memory system (interaction history, request projection, logical execution chain), and details token‑budget constraints, prompt‑caching trade‑offs, and a suite of context‑compression strategies to keep agents reliable across long conversations.

Agent MemoryEvent SourcingLLM
0 likes · 16 min read
How to Stop Large‑Model Coding Agents from Forgetting in Multi‑Turn Dialogues
Data Bricklaying Diary
Data Bricklaying Diary
Aug 18, 2026 · Artificial Intelligence

Semantic Models ≠ Live State: Why Agents Need Object Runtime

This article distinguishes semantic models (which define business object meanings) from object runtime (which provides traceable, versioned projections of specific object states for AI agents), detailing five core responsibilities, differences from data platforms and agent runtimes, a credit-adjustment case study, and guidance on when and how to implement minimal object projections.

Agent ArchitectureCDCDigital Twin
0 likes · 21 min read
Semantic Models ≠ Live State: Why Agents Need Object Runtime
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.

CQRSEvent SourcingOutbox
0 likes · 32 min read
Event Sourcing Primer: Rebuilding State Without a Database
Xiaolin Talks Programming
Xiaolin Talks Programming
Aug 12, 2026 · Backend Development

Spring Boot + Temporal: Mastering Microservice Long Transactions, Saga Compensation & Production Pitfalls

This article provides a comprehensive guide to integrating Temporal with Spring Boot for handling long-running distributed transactions, covering core architecture, Saga compensation patterns, activity retries, versioning, debugging, transaction boundary isolation, multi-tenancy, and production monitoring with concrete code examples and pitfalls.

Event SourcingSaga PatternSpring Boot
0 likes · 21 min read
Spring Boot + Temporal: Mastering Microservice Long Transactions, Saga Compensation & Production Pitfalls
DeepNoMind
DeepNoMind
Aug 8, 2026 · Fundamentals

Stop Chasing Frameworks: Master These 7 Architecture Patterns First

This article breaks down seven practical software‑architecture patterns—Bounded Context, Sidecar, Publisher‑Subscriber, Application Gateway, Microservices, Micro‑frontends, and CQRS/Event Sourcing—showing how they can be combined in a real e‑commerce system and guiding architects on when each pattern best solves complexity, performance, or team‑collaboration challenges.

CQRSDesign PatternsEvent Sourcing
0 likes · 17 min read
Stop Chasing Frameworks: Master These 7 Architecture Patterns First
Xiaolin Talks Programming
Xiaolin Talks Programming
Jul 13, 2026 · Backend Development

CQRS & Event Sourcing in Spring Boot: Read/Write Separation, Snapshots & Compensation

This guide details implementing CQRS and Event Sourcing in Spring Boot, covering command/query separation, event bus choices (Outbox pattern, Kafka), projection idempotency, state snapshots for performance, Saga-based compensation for distributed transactions, and practical tuning tips for production workloads.

CQRSEvent BusEvent Sourcing
0 likes · 14 min read
CQRS & Event Sourcing in Spring Boot: Read/Write Separation, Snapshots & Compensation
AI Engineering
AI Engineering
Jul 11, 2026 · Artificial Intelligence

Why Logs Should Be the Agent Itself, Not Just a Byproduct

The article analyzes Yohei Nakajima’s "The Log is the Agent" paper, showing how ActiveGraph unifies goals, rules, tool calls, LLM responses, and artifacts into a single append‑only event log, enabling deterministic replay, cheap forking, and full provenance for LLM‑driven agents.

ActiveGraphAgent ArchitectureEvent Sourcing
0 likes · 13 min read
Why Logs Should Be the Agent Itself, Not Just a Byproduct
Random Bulletin
Random Bulletin
Jun 8, 2026 · R&D Management

How a Simple “Go Check the Floor” Request Reveals Stream vs State Data Inefficiencies

The article shows that asking team members to scroll through long chat histories (“go check the floor”) forces them to replay log‑style data, which is costly and error‑prone, and argues that using state‑oriented tools such as task boards and documentation—akin to materialized views—eliminates this inefficiency.

Event SourcingMaterialized Viewcognitive load
0 likes · 13 min read
How a Simple “Go Check the Floor” Request Reveals Stream vs State Data Inefficiencies
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.

CQRSDDDEvent Sourcing
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.

CQRSCQSCommand Query Separation
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.

CQRSDomain-Driven DesignEvent Sourcing
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.

CQRSEvent SourcingKafka
0 likes · 14 min read
Stop Fighting Microservice Calls—Why Experts Prefer Event‑Driven Architecture for Decoupling Distributed Systems
AI Tech Publishing
AI Tech Publishing
Apr 19, 2026 · Artificial Intelligence

How to Build Production‑Ready Agent HITL: State Machines, Event Sourcing, and Distributed Coordination

The article presents a detailed engineering guide for deploying production‑grade AI agents with Human‑in‑the‑Loop, covering a three‑layer decoupled architecture, tool‑level and hook‑level interception, a six‑state session state machine with event sourcing, robust timeout handling using CAS, and cross‑node coordination for multi‑agent workflows.

AgentDistributed CoordinationEvent Sourcing
0 likes · 17 min read
How to Build Production‑Ready Agent HITL: State Machines, Event Sourcing, and Distributed Coordination
IT Architects Alliance
IT Architects Alliance
Nov 4, 2025 · Backend Development

Mastering Distributed Data Consistency: Strategies, Patterns, and Best Practices

This article explores the challenges of maintaining data consistency in distributed microservice architectures, covering CAP theory, consistency models, replication strategies, transaction patterns like Saga and TCC, tooling choices, monitoring practices, and actionable best‑practice recommendations.

CAP theoremData ConsistencyEvent Sourcing
0 likes · 13 min read
Mastering Distributed Data Consistency: Strategies, Patterns, and Best Practices
IT Architects Alliance
IT Architects Alliance
Oct 5, 2025 · Backend Development

How to Ensure Data Consistency Across Microservices: Strategies & Code

This article explores the challenges of maintaining data consistency in microservice architectures and presents practical solutions such as distributed transactions, Saga patterns, event sourcing with CQRS, message‑queue choices, database strategies, monitoring techniques, and best‑practice guidelines for reliable implementation.

Data ConsistencyEvent SourcingSaga Pattern
0 likes · 11 min read
How to Ensure Data Consistency Across Microservices: Strategies & Code
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.

AxonCQRSEvent Sourcing
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.

CQRSEvent SourcingJava
0 likes · 12 min read
Understanding CQRS and Implementing It with Spring Microservices
IT Architects Alliance
IT Architects Alliance
Sep 28, 2024 · Backend Development

Understanding CQRS (Command Query Responsibility Segregation): Concepts, Implementation, Advantages, Challenges, and Best Practices

This article explores the CQRS (Command Query Responsibility Segregation) pattern, detailing its core concepts, implementation approaches—including logical, storage, and asynchronous separation—its benefits and challenges, and practical best‑practice guidelines for applying CQRS in modern high‑performance, scalable systems.

Event SourcingJavaarchitecture
0 likes · 12 min read
Understanding CQRS (Command Query Responsibility Segregation): Concepts, Implementation, Advantages, Challenges, and Best Practices
Top Architecture Tech Stack
Top Architecture Tech Stack
Jul 4, 2024 · Backend Development

Service Communication in Microservices: RPC vs Event‑Driven, Coupling Types, and Design Patterns

The article explains how microservice architectures handle inter‑service calls using RPC or event‑driven approaches, analyzes different coupling types, compares event notification with event sourcing, and offers practical guidance on API gateways, service composition, and when to choose each communication style.

API GatewayEvent SourcingRPC
0 likes · 20 min read
Service Communication in Microservices: RPC vs Event‑Driven, Coupling Types, and Design Patterns
Architect
Architect
Mar 11, 2024 · Backend Development

Understanding Service Coupling: RPC vs Event‑Driven Approaches in Microservice Architecture

The article explains how microservice systems handle service calls, compares RPC and event‑driven (message) communication, details various coupling types, discusses event notification and event sourcing, and offers practical guidance on reducing tight coupling through API gateways, versioning, and gRPC.

Event SourcingRPCbackend architecture
0 likes · 21 min read
Understanding Service Coupling: RPC vs Event‑Driven Approaches in Microservice Architecture
ITPUB
ITPUB
Dec 24, 2023 · Backend Development

Why Kafka Is the Backbone of Modern Messaging, Streaming, and Data Pipelines

This article explains how Kafka serves as a high‑throughput, durable messaging system, a reliable storage layer, a log‑aggregation hub, a stream‑processing engine, and a core component for CDC, system migration, monitoring, and event‑sourcing architectures.

CDCEvent SourcingKafka
0 likes · 9 min read
Why Kafka Is the Backbone of Modern Messaging, Streaming, and Data Pipelines
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.

AxonCQRSEvent Sourcing
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.

CQRSEvent SourcingJava
0 likes · 13 min read
Understanding CQRS and Implementing It with Spring Microservices
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.

CQRSDomain-Driven DesignEvent Sourcing
0 likes · 12 min read
Domain-Driven Design and Its Relationship with Redux
MaGe Linux Operations
MaGe Linux Operations
May 28, 2023 · Backend Development

When to Use RPC vs Event‑Driven Architecture in Microservices?

This article examines microservice communication, comparing RPC and event‑driven approaches, explains different types of coupling, explores event notification and event sourcing, discusses API gateways and internal microservice design, and offers guidance on choosing the right integration method and managing service count.

Event SourcingRPCevent-driven
0 likes · 21 min read
When to Use RPC vs Event‑Driven Architecture in Microservices?
Cloud Native Technology Community
Cloud Native Technology Community
Feb 14, 2023 · Backend Development

Service Coupling, RPC vs Event‑Driven Communication, and Microservice Design Strategies

The article examines how microservices interact, compares RPC and event‑driven approaches, analyzes different types of coupling, discusses event notification, event sourcing, API gateways, versioning, and offers practical guidance on reducing tight coupling and deciding the appropriate microservice architecture.

Event SourcingRPCbackend architecture
0 likes · 19 min read
Service Coupling, RPC vs Event‑Driven Communication, and Microservice Design Strategies
dbaplus Community
dbaplus Community
Jan 28, 2023 · Backend Development

When Should You Choose Event‑Driven Over RPC in Microservices?

This article examines the trade‑offs between RPC and event‑driven communication in microservice architectures, detailing different types of coupling, the benefits and drawbacks of event notification and event sourcing, practical examples, and strategies such as API gateways and internal microservice design to reduce tight coupling.

API GatewayCouplingEvent Sourcing
0 likes · 22 min read
When Should You Choose Event‑Driven Over RPC in Microservices?
Java Architect Essentials
Java Architect Essentials
Oct 28, 2022 · Backend Development

Understanding Service Coupling: RPC vs. Event‑Driven Approaches in Microservice Architecture

The article explains the different kinds of coupling in microservice communication, compares RPC and event‑driven (event notification and event sourcing) approaches, discusses API gateways, service versioning, and offers practical guidance on when to use each method while highlighting the challenges of tight coupling and internal microservice design.

API GatewayEvent SourcingRPC
0 likes · 20 min read
Understanding Service Coupling: RPC vs. Event‑Driven Approaches in Microservice Architecture
Architecture Digest
Architecture Digest
Oct 7, 2022 · Backend Development

Understanding Service Coupling, RPC vs Event‑Driven Communication, and Event Sourcing in Microservices

The article explains the different types of service coupling in microservice architectures, compares RPC and event‑driven approaches—including event notification and event sourcing—provides practical examples, discusses API gateways and strategies to reduce tight coupling, and concludes with guidance on internal microservice design and when to adopt microservices.

Event SourcingRPCbackend architecture
0 likes · 19 min read
Understanding Service Coupling, RPC vs Event‑Driven Communication, and Event Sourcing in Microservices
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.

CQRSDesign PatternsEvent Sourcing
0 likes · 28 min read
Microservice Architecture Design Patterns: Benefits, Drawbacks, and Usage Guidelines
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.

CQRSCQSDDD
0 likes · 12 min read
Why CQRS Matters: Evolving Monoliths into Scalable Systems
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 GatewayCQRSDesign Patterns
0 likes · 22 min read
From Monolith to Event‑Driven Microservices: A Step‑by‑Step Architecture Blueprint
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 GatewayCQRSCircuit Breaker
0 likes · 15 min read
Top Microservices Design Patterns for Building Applications
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.

BackendCQRSEvent Sourcing
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.

CQRSEvent Sourcingbackend design
0 likes · 18 min read
Event-Driven Architecture: Concepts, Scenarios, and Implementation Practices
Programmer DD
Programmer DD
Oct 29, 2021 · Backend Development

How Keep Revamped Its E‑Commerce Supply Chain with DDD and EventStore

This article details Keep’s practical application of Domain‑Driven Design to overhaul its e‑commerce supply‑chain system, describing the legacy challenges, the step‑by‑step DDD restructuring—including inventory modeling, bounded contexts, hexagonal architecture, CQRS, event sourcing, and testing—plus the resulting benefits and best‑practice insights.

DDDEvent SourcingJava
0 likes · 9 min read
How Keep Revamped Its E‑Commerce Supply Chain with DDD and EventStore
IT Architects Alliance
IT Architects Alliance
Oct 7, 2021 · Backend Development

Applying DDD to Refactor Keep's E‑commerce Supply‑Chain System

This article describes how Keep used Domain‑Driven Design, bounded contexts, hexagonal architecture, CQRS, and an EventStore‑based event‑sourcing solution to rebuild its legacy supply‑chain (inventory) system, improve inventory accuracy, simplify extensions, and establish a reusable DDD practice for future micro‑service development.

DDDEvent SourcingSupply Chain
0 likes · 7 min read
Applying DDD to Refactor Keep's E‑commerce Supply‑Chain System
Architecture Digest
Architecture Digest
Oct 1, 2021 · Backend Development

Refactoring a Legacy Supply‑Chain System with DDD, Hexagonal Architecture, and EventStore

The article details how a legacy e‑commerce supply‑chain system plagued by unclear boundaries, inventory inaccuracies, and tangled dependencies was redesigned using domain‑driven design, hexagonal architecture, CQRS, and an EventStore solution, resulting in accurate inventory, easier extensions, and a reusable event‑driven component.

BackendDDDEvent Sourcing
0 likes · 10 min read
Refactoring a Legacy Supply‑Chain System with DDD, Hexagonal Architecture, and EventStore
ITFLY8 Architecture Home
ITFLY8 Architecture Home
Sep 30, 2021 · Backend Development

How DDD and Event Sourcing Revamped a Legacy Supply‑Chain System

This article details how a tangled, legacy supply‑chain system was re‑engineered using domain‑driven design, hexagonal architecture, CQRS, and an EventStore solution, resulting in accurate inventory, clearer boundaries, easier extensions, and a reusable event‑driven component for future e‑commerce projects.

DDDEvent Sourcingbackend architecture
0 likes · 10 min read
How DDD and Event Sourcing Revamped a Legacy Supply‑Chain System
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 GatewayCQRSDesign Patterns
0 likes · 28 min read
Top Microservice Design Patterns: Database per Service, Event Sourcing, CQRS, Saga
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.

CQRSDomain-Driven DesignEvent Sourcing
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.

CQRSEvent SourcingSAGA
0 likes · 26 min read
Design Patterns for Microservice Architecture
IT Architects Alliance
IT Architects Alliance
Jun 14, 2021 · Backend Development

When Should You Choose RPC vs Event‑Driven in Microservices?

The article analyzes microservice communication patterns, comparing RPC and event‑driven approaches, explains different types of coupling, explores event notification and event sourcing, discusses API gateways, versioning strategies, and offers guidance on sizing microservice architectures and internal microservice design.

API GatewayEvent SourcingRPC
0 likes · 21 min read
When Should You Choose RPC vs Event‑Driven in Microservices?
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.

AggregatesCQRSDomain-Driven Design
0 likes · 37 min read
Understanding Domain-Driven Design: Core Concepts, Layers, and Patterns
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.

AggregatesCQRSDomain-Driven Design
0 likes · 36 min read
Understanding Domain-Driven Design: Core Concepts, Layers, and Patterns
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.

BFFCQRSCircuit Breaker
0 likes · 11 min read
Modern Architecture Design Patterns for Scalable Applications
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.

CQRSEvent SourcingSAGA
0 likes · 17 min read
Microservice Architecture Communication Design Patterns
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
Architecture Digest
Architecture Digest
Nov 24, 2020 · Backend Development

Saga Pattern for Distributed Data Consistency in Microservices

This article explains why data consistency is critical in microservice architectures, introduces the Saga pattern as a solution for achieving eventual consistency, compares it with two‑phase commit and TCC, and details the design of a centralized Saga framework including logging, recovery, and execution components.

Event Sourcingmicroservices
0 likes · 19 min read
Saga Pattern for Distributed Data Consistency in Microservices
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 FrameworkCQRSDomain-Driven Design
0 likes · 11 min read
Applying Axon Framework and Spring StateMachine in iQIYI Contract Platform: Architecture, Practices, and Lessons
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.

BackendCQRSDesign Patterns
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.

CQRSDomain EventsDomain-Driven Design
0 likes · 21 min read
Applying Domain Events, Saga, and CQRS in Domain-Driven Design
Architect's Tech Stack
Architect's Tech Stack
Mar 18, 2020 · Backend Development

Service Calls in Microservice Architecture: RPC vs Event‑Driven, Coupling Types, and Design Strategies

The article explains how microservices communicate via RPC or event‑driven approaches, analyzes different coupling types, compares event notification and event sourcing, discusses API‑gateway and service composition, and offers practical guidance on limiting microservice count and using internal microservice design.

API GatewayCouplingEvent Sourcing
0 likes · 19 min read
Service Calls in Microservice Architecture: RPC vs Event‑Driven, Coupling Types, and Design Strategies
Architects Research Society
Architects Research Society
Mar 6, 2020 · Backend Development

Ensuring Data Consistency Across Microservices: Saga, Reconciliation, Event Sourcing, and Change Data Capture

The article explains why achieving data consistency across multiple microservices is challenging, reviews the limitations of two‑phase commit, and presents practical techniques such as the Saga pattern, reconciliation, event logs, orchestration vs. choreography, and change‑data‑capture to keep distributed systems eventually consistent.

CDCData ConsistencyEvent Sourcing
0 likes · 12 min read
Ensuring Data Consistency Across Microservices: Saga, Reconciliation, Event Sourcing, and Change Data Capture
Senior Brother's Insights
Senior Brother's Insights
Jan 8, 2020 · Backend Development

When to Prefer Event‑Driven Over RPC for Microservice Communication?

This article examines how microservices interact, compares RPC and event‑driven approaches, explains different coupling types, outlines event notification and event sourcing patterns, discusses API gateways and strategies to reduce tight coupling, and introduces internal microservice design as a pragmatic compromise.

API GatewayEvent Sourcinginternal microservice design
0 likes · 21 min read
When to Prefer Event‑Driven Over RPC for Microservice Communication?
Architecture Digest
Architecture Digest
Nov 9, 2019 · Backend Development

Design and Implementation of eBay's Next‑Generation Million‑TPS Core Accounting System

The article details eBay's 2018‑2020 design, performance testing, and fault‑tolerance architecture of a next‑generation core accounting system capable of handling millions of transactions per second, covering system goals, multi‑region deployment, event‑sourcing, Raft consensus, scalability optimizations, and the planned open‑source release.

Distributed ArchitectureEvent SourcingHigh TPS
0 likes · 24 min read
Design and Implementation of eBay's Next‑Generation Million‑TPS Core Accounting System
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.

CQRSCRUDDDD
0 likes · 29 min read
Understanding Domain-Driven Design (DDD) and Its Role in Solving CRUD Problems
dbaplus Community
dbaplus Community
Jun 18, 2019 · Backend Development

How to Escape the “Big Ball of Mud”: Practical Strategies for Splitting Monolithic Systems

This article examines why monolithic, tangled codebases—dubbed the Big Ball of Mud—fail due to performance, complexity, and organizational mismatches, and presents a series of concrete architectural remedies such as domain modeling, service decomposition, ESB avoidance, asynchronous messaging, and event sourcing to achieve stable, maintainable systems.

Domain ModelEvent SourcingSystem Design
0 likes · 21 min read
How to Escape the “Big Ball of Mud”: Practical Strategies for Splitting Monolithic Systems
Architects Research Society
Architects Research Society
Jun 11, 2019 · Fundamentals

Key Trends and Insights in Architecture and Design (2019)

The article analyzes current and emerging software architecture trends such as evolutionary architecture, microservices adoption, event sourcing, serverless, and the evolving role of architects, highlighting which concepts are moving toward mainstream adoption and which remain niche.

Event SourcingServerlessevolutionary architecture
0 likes · 18 min read
Key Trends and Insights in Architecture and Design (2019)
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
Architecture Digest
Architecture Digest
Nov 20, 2017 · Cloud Native

Evolution of Microservice Systems Toward a Reactive Microsystem Architecture

The article explains how traditional microservice architectures evolve into event‑driven reactive microsystems by adopting events‑first DDD, reactive design, and event‑based persistence, highlighting the role of the Actor model, asynchronous non‑blocking communication, event sourcing, and saga‑based distributed transaction handling.

DDDEvent Sourcingdistributed systems
0 likes · 9 min read
Evolution of Microservice Systems Toward a Reactive Microsystem Architecture
GF Securities FinTech
GF Securities FinTech
Sep 28, 2016 · Backend Development

How Event Sourcing and a Go DSL Power a Scalable Points System

This article explains how a financial e‑commerce platform uses the Event Sourcing architecture pattern, an asynchronous message bus, and a Go‑based domain‑specific language to build a flexible, exactly‑once points system that decouples business rules from application code and simplifies operations.

DSLEvent SourcingGo
0 likes · 17 min read
How Event Sourcing and a Go DSL Power a Scalable Points System
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.

CQRSEvent Sourcingdistributed 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.

CQRSConcurrencyDomain-Driven Design
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.

CQRSDDDDomain-Driven Design
0 likes · 25 min read
Rethinking 12306 Ticketing: A Domain‑Driven Design Model for Complex Train Reservations
Art of Distributed System Architecture Design
Art of Distributed System Architecture Design
Apr 15, 2015 · Big Data

Understanding Stream Processing, Event Sourcing, and Complex Event Processing

The article explains the fundamentals of stream processing, event sourcing, and complex event processing, comparing raw event storage with aggregated results, illustrating architectures with Kafka, Samza, and other frameworks, and highlighting benefits such as scalability, flexibility, and decoupling for modern data‑driven systems.

Apache KafkaApache SamzaEvent Sourcing
0 likes · 11 min read
Understanding Stream Processing, Event Sourcing, and Complex Event Processing