Tagged articles
Bounded Context
70 articles · Page 1 of 1
A real e-commerce stress test reveals a distributed monolith where services are physically separated but logically coupled via shared databases, synchronous write chains, and shared domain models. The article dissects three coupling layers, control-plane risks, and an incremental decoupling strategy with an architectural review checklist.
Bounded Contextarchitectural reviewcoupling analysis
0 likes · 24 min read

This article explores how software topology determines evolvability through connascence-based coupling analysis, architectural quanta as independently deployable units, contract spectra from strict RPC to loose key-value, microservices as evolutionary templates, data mesh for analytical data, and evolutionary database practices including Expand/Contract migrations and data governance.
Bounded ContextDatabase Migrationarchitectural quantum
0 likes · 56 min read

This article explores architectural decomposition for a cement industrial platform, distinguishing business, code, and deployment boundaries, advocating modular monoliths over premature microservices, and detailing domain-driven design, bounded contexts, transaction boundaries, CQRS, and a practical migration strategy with evaluation criteria.
Bounded Contextarchitecture decision recordcement industry
0 likes · 33 min read

This article presents a comprehensive software design methodology spanning strategic design (bounded contexts, domain partitioning, architectural style selection), tactical design (functional and non-functional modeling), structural modeling (class responsibilities, package structure), behavioral modeling (sequence diagrams, state machines), and DFX (design for performance, reliability, cost) — with concrete code examples and real-world failure patterns.
Bounded ContextCircuit BreakerSaga pattern
0 likes · 34 min read

This article explains how Domain-Driven Design (DDD) guides microservice splitting through three steps: enforcing high cohesion and low coupling principles, dividing systems into core, supporting, and generic domains via bounded contexts, and using message queues for asynchronous event-driven decoupling, illustrated with an online food ordering example.
Bounded ContextDDDMessage Queue
0 likes · 8 min read

This article explains why effective service boundaries require aligning business rules, data ownership, change rhythms, and team responsibilities—not just drawing boxes around nouns—using a refund processing case study to compare modular monolith vs. microservice trade-offs and verify boundaries through concrete evidence.
Architecture DesignBounded ContextData Ownership
0 likes · 21 min read

This article provides a comprehensive overview of microservices architecture, covering bounded contexts, service granularity, API layers, sidecar/service mesh patterns, communication styles, data topology, distributed transactions with Saga, common anti-patterns, characteristic ratings, and team topology alignment.
Bounded ContextSaga patterndatabase-per-service
0 likes · 23 min read

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.
Bounded Contextcqrsdesign patterns
0 likes · 17 min read

This article analyzes microservice architecture decay through a real e-commerce case study, detailing root causes of circular dependencies (direct and indirect), four practical elimination strategies (domain events, shared contexts, data snapshots, context merging), ongoing governance practices (visualization, review gates, dependency classification), and a six-step iterative boundary reconstruction process to maintain architectural quality during continuous business evolution.
Bounded Contextarchitecture-decaycircular-dependencies
0 likes · 18 min read

This article explains how to implement DDD's four-layer architecture (Interface, Application, Domain, Infrastructure) to map bounded contexts to code structure, eliminate anemic domain models by embedding business logic in aggregates, enforce layer boundaries, and use domain events for cross-context communication, with Java package examples and common pitfalls.
Bounded ContextDDDJava
0 likes · 13 min read

This tutorial teaches Event Storming, a Domain-Driven Design technique for defining microservice boundaries, through a five-step process (identify actors, commands, events, aggregates, bounded contexts) demonstrated with an e-commerce order example, plus mapping to DDD layered architecture and common pitfalls.
Bounded ContextDDDE-commerce Example
0 likes · 9 min read

This article explains why 90% of teams fail at microservice decomposition, details three common anti-patterns, and provides a complete DDD-based four-step process for defining bounded contexts, modeling aggregates, and implementing strategic and tactical patterns to eliminate distributed monoliths and reduce distributed transactions.
AggregateBounded ContextDDD
0 likes · 13 min read

This article walks through a complete DDD strategic‑design workshop for a community‑focused retail e‑commerce system, showing how to identify business goals, split sub‑domains, decide core versus supporting domains, define bounded contexts, build a unified language, draw context maps, capture risks, and prepare review artefacts before moving to tactical design.
Bounded ContextDDDStrategic Design
0 likes · 33 min read

The article uses the ambiguous term “product” across product, inventory, order, and promotion teams to illustrate how bounded contexts and a ubiquitous language prevent model confusion, guide code organization, and enable safe evolution of a Spring Boot system.
Bounded ContextDDDdomain modeling
0 likes · 13 min read

The article explains how to integrate multiple bounded contexts in a payroll system by using four DDD‑based relationship patterns—Shared Kernel, Customer‑Supplier, Anti‑Corruption Layer, and Open Host Service—detailing their motivations, code organization, risks, and selection criteria.
Anti-Corruption LayerBounded ContextContext Mapping
0 likes · 17 min read

The article explains how bounded contexts, defined by language boundaries rather than functional ones, guide the logical separation of a payroll system into distinct domains, illustrating the process with concrete terminology lists, ambiguity detection, authority mapping, code examples, and deployment‑agnostic module structures.
Bounded Contextbackend architecturedomain-driven design
0 likes · 13 min read

This article introduces architecture quantum as the boundary for architectural characteristics, explaining why system-level assumptions fail in microservices. It details four coupling types — semantic, implementation, static, and dynamic — and defines architecture quantum by four properties: independent deployability, high functional cohesion, low external static coupling, and synchronous communication, guiding architectural style selection.
Bounded Contextarchitectural characteristicsarchitectural style selection
0 likes · 6 min read


ZhiKe AIJun 2, 2026 · Backend Development
The article argues that Domain‑Driven Design is not an architectural style but a two‑layer framework—strategic design defines bounded contexts and ubiquitous language, while tactical design supplies the modeling tools—explaining common misreadings and showing how DDD complements Clean, Hexagonal, CQRS, and Event Sourcing approaches.
Bounded ContextStrategic Designaggregates
0 likes · 14 min read

A comprehensive practical guide to implementing Domain-Driven Design in complex business systems, covering bounded context division using Event Storming and subdomain analysis, aggregate root and entity design with code examples, domain event patterns for decoupling and eventual consistency, and integrating DDD with Spring Boot's layered architecture using onion/clean architecture principles.
Aggregate RootBounded ContextDDD
0 likes · 37 min read

The article explains how Domain‑Driven Design addresses the pitfalls of bloated services, unclear boundaries, and inconsistent terminology by introducing bounded contexts, aggregates, and domain events, and outlines a step‑by‑step adoption process while debunking common misconceptions.
Bounded ContextEvent Stormingaggregates
0 likes · 9 min read

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.
Bounded ContextMyBatis Plusaggregates
0 likes · 8 min read

The article explains how to translate business architecture boxes into concrete micro‑service designs, outlines a four‑step mapping method, defines service granularity, contracts, cross‑cutting concerns, diagram notation, and presents two diagram styles with real‑world pitfalls and best‑practice recommendations.
Application ArchitectureArchitecture DiagramBounded Context
0 likes · 18 min read

This article explains the evolution from basic SaaS monoliths to cloud‑native microservices, detailing IAAS/PAAS/SaaS models, the concept of bounded contexts in domain‑driven design, and how architectural patterns such as clean, hexagonal, and onion layers help achieve modular, scalable systems.
Bounded Contextcloud computingdomain-driven design
0 likes · 8 min read

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 Contextcqrsdomain-driven design
0 likes · 9 min read

This article provides a comprehensive introduction to Domain‑Driven Design (DDD), covering its origins, core principles, layered architecture, key concepts such as entities, value objects, aggregates, bounded contexts, and how DDD improves communication and maintainability in complex software systems.
Bounded ContextValue Objectdomain-driven design
0 likes · 6 min read

This article explains how to design microservice architectures by applying domain‑driven design concepts such as bounded contexts and aggregates, using context mapping and event‑storming techniques to define clear service boundaries, handle communication, and balance consistency with availability.
Bounded ContextContext MappingEvent Storming
0 likes · 21 min read

The article explains Domain‑Driven Design’s philosophy of aligning business language with code, defines key concepts such as bounded contexts, entities, value objects, aggregates, and shows how these ideas translate into microservice decomposition, event‑driven integration, and reduced coupling for cloud‑native systems.
Aggregate RootBounded ContextDDD
0 likes · 16 min read

This article explains how to apply Domain-Driven Design (DDD) to a new project, covering terminology, architecture evolution from IAAS/PAAS/SAAS, bounded‑context boundaries, the four DDD layers, clean layered, hexagonal and onion architectures, and practical guidance for backend development.
Bounded ContextDDDOnion Architecture
0 likes · 9 min read

This article explains how to start a new project using Domain-Driven Design, covering IAAS/PAAS/SAAS terminology, architecture evolution, bounded contexts, the four DDD boundaries, clean layered, hexagonal, and onion architectures, and their impact on microservice design.
Bounded Contextarchitectureclean architecture
0 likes · 10 min read

The article systematically examines Domain‑Driven Design through four discourses—Structure, Process, Language, and Modeling—while contrasting the practical “folk” school with the academic school, linking philosophical ideas, software‑complexity theory, strategic and tactical design, refactoring, agile practices, ubiquitous language, and its parallels to UML/SysML, arguing DDD repackages existing engineering concepts rather than inventing new ones.
Bounded ContextDDD Strategic DesignDDD Tactical Design
0 likes · 17 min read

This article explains how applying Domain-Driven Design principles to front‑end projects clarifies business boundaries, improves code organization, reduces maintenance costs, and enables better collaboration across product, front‑end, and back‑end teams.
Bounded ContextFrontend Architecturecode organization
0 likes · 14 min read


DevOpsJul 21, 2023 · Fundamentals
This article explains how business complexity arises from scale and domain logic, and demonstrates how Domain‑Driven Design—through subdomains, bounded contexts, orthogonal business‑technology separation, consistent code models, and strategic‑tactical design—helps manage and reduce that complexity in software systems.
Bounded ContextBusiness Complexityaggregates
0 likes · 10 min read

This article explains how to start a new project using Domain‑Driven Design, covering key terminology, architecture evolution, bounded contexts, the four DDD boundaries, and common architectural styles such as clean layered, hexagonal, and onion architectures.
Bounded ContextDDDclean architecture
0 likes · 9 min read

This article explains how to apply Domain-Driven Design (DDD) from project inception, covering key terminology, architectural evolution, bounded contexts, the four DDD boundaries, and various layered architectures such as clean, hexagonal, and onion models to achieve modular, maintainable systems.
Bounded Contextclean architecturedomain-driven design
0 likes · 9 min read

This article explains the complete Domain‑Driven Design (DDD) workflow, covering the problem‑space analysis, bounded‑context mapping, layered architecture, and the three modeling phases—analysis, design, and implementation—while emphasizing unified language, core, generic, and supporting sub‑domains.
Bounded Contextdomain-driven designlayered architecture
0 likes · 16 min read

This article explains how to start a new project using Domain‑Driven Design, covering terminology, architectural evolution across SaaS, PaaS, IaaS, bounded‑context division, the four DDD boundaries, clean layered, hexagonal and onion architectures, and concludes with practical guidance.
Bounded ContextDDDOnion Architecture
0 likes · 8 min read

This article explains the fundamentals of Domain‑Driven Design, covering its core ideas such as model‑driven design, ubiquitous language, bounded contexts, layered and hexagonal architectures, and key building blocks like entities, value objects, aggregates, repositories, factories, and services, with practical examples and diagrams.
Bounded ContextDDDValue Objects
0 likes · 23 min read

This article explains how to apply Domain‑Driven Design (DDD) to a brand‑new project, covering essential terminology, architecture evolution across SaaS, PaaS, IaaS, bounded‑context segmentation, the four DDD boundaries, clean layered, hexagonal, and onion architectures, and provides practical guidance for effective system design.
Bounded ContextOnion Architectureclean architecture
0 likes · 9 min read

This article explains Domain‑Driven Design fundamentals, covering how to define bounded contexts and subdomains, the criteria for domain division, practical modeling experiences, and detailed guidance on modeling entities and value objects with illustrative Go code examples.
Bounded ContextDDDValue Object
0 likes · 14 min read

This article explains how to start a new project using Domain‑Driven Design, covering terminology, architecture evolution from monolith to microservices, bounded‑context definition, the four DDD boundaries, clean layered, hexagonal and onion architectures, and practical guidelines for effective system design.
Bounded ContextOnion Architectureclean architecture
0 likes · 9 min read

This article explains how to start a new project using Domain‑Driven Design, covering key terminology, the evolution of architecture layers, bounded context concepts, the four DDD boundaries, and various architectural styles such as clean layered, hexagonal, and onion architectures.
Bounded Contextclean architecturedomain-driven design
0 likes · 10 min read

This article explains how to start a new project using Domain‑Driven Design, covering terminology, the evolution from SaaS to IaaS, bounded‑context concepts and division rules, the four DDD boundaries, and how clean, hexagonal, and onion architectures realize these principles for scalable backend systems.
BackendBounded ContextOnion Architecture
0 likes · 9 min read

This article explains how Domain-Driven Design (DDD) complements microservice architecture by addressing functional decomposition, defining bounded contexts, and improving system evolution, while also highlighting common microservice pitfalls and practical guidelines for splitting complex systems.
Bounded ContextDDDarchitecture
0 likes · 8 min read

This article explains how to apply Domain-Driven Design (DDD) to a new project, detailing the evolution from monolithic to microservice architectures, the concepts of IaaS, PaaS, SaaS, bounded contexts, the four DDD boundaries, and clean, hexagonal, and onion architectural patterns.
Bounded ContextDDDOnion Architecture
0 likes · 9 min read

This article explores how microservice architecture, guided by Domain‑Driven Design principles such as bounded contexts, aggregates, and context mapping, defines service boundaries, improves autonomy, and influences communication patterns, including event‑driven integration, synchronous APIs, and BFF strategies, while addressing consistency, scalability, and deployment challenges.
Bounded ContextEvent Stormingdomain-driven design
0 likes · 22 min read


DevOpsJun 12, 2022 · Fundamentals
The article explains how software complexity arises from scale, structure, and change, and shows that controlling dependencies through bounded contexts and aggregates—by reducing dependency quantity and weakening dependency strength—provides a practical way to achieve high cohesion and low coupling in system architecture.
AggregateBounded ContextDependency Management
0 likes · 11 min read


DevOpsJun 10, 2022 · Fundamentals
The article explains how software complexity stems from scale, structure, and change, and shows that controlling dependencies—by reducing their number and weakening their strength—through bounded contexts and aggregates is the key to achieving high cohesion and low coupling in domain‑driven design.
AggregateBounded ContextDependency Management
0 likes · 12 min read

The article explains microservices architecture, detailing its defining characteristics, the role of domain‑driven design and bounded contexts, how aggregates and context mapping help define service boundaries, and discusses communication patterns, eventual consistency, event‑storming, and the backend‑for‑frontend approach for building resilient, loosely‑coupled systems.
Bounded ContextEvent Stormingmicroservices
0 likes · 20 min read

This article explains how microservice architecture leverages Domain‑Driven Design concepts such as bounded contexts and aggregates, uses context mapping and Event Storming to define service boundaries, and discusses communication patterns, eventual consistency, and Backend‑for‑Frontend design to build resilient, loosely‑coupled distributed systems.
Bounded ContextEvent Stormingdistributed systems
0 likes · 18 min read

This article explains how microservice architecture differs from traditional service‑oriented designs, outlines its key characteristics, and shows how Domain‑Driven Design, bounded contexts, aggregates, context mapping, and event‑storming can be used to define clear service boundaries and build resilient, loosely‑coupled systems.
Bounded ContextEvent Stormingarchitecture
0 likes · 20 min read

This article introduces Domain‑Driven Design, explaining its strategic and tactical aspects, core concepts such as bounded contexts, ubiquitous language, aggregates, entities, and value objects, and illustrates how DDD can be applied to complex business domains like hotel transaction systems.
Bounded ContextStrategic Designdomain-driven design
0 likes · 17 min read

This article walks through Domain‑Driven Design fundamentals, distinguishes strategic and tactical design, introduces the four‑color modeling archetypes, and demonstrates their application in an e‑commerce microservice case study, highlighting how DDD bridges business requirements and code architecture.
Bounded ContextDCI ModelingFour-Color Modeling
0 likes · 14 min read

This article explains how Airwallex uses Domain-Driven Design (DDD) to model a complex payment system, covering problem and solution spaces, bounded contexts, domain models, services, events, infrastructure, and the transition from domain concepts to microservices.
Bounded Contextdomain eventspayment system
0 likes · 10 min read

Domain-Driven Design (DDD) is a model‑driven approach that places the business domain at the core, using ubiquitous language, bounded contexts, and building blocks such as entities, value objects, and services to create a cohesive domain model that aligns code with complex business requirements.
Bounded Contextdomain modelingsoftware architecture
0 likes · 9 min read

This article explains the principles of microservices architecture, the role of bounded contexts and domain‑driven design, and practical techniques such as context mapping, event storming, and BFF patterns for defining service boundaries, handling communication, and achieving resilient, loosely‑coupled systems.
Bounded ContextEvent Stormingmicroservices
0 likes · 19 min read

This article explains how to apply Domain-Driven Design (DDD) from project inception, covering terminology, architecture evolution across SaaS, PaaS, IaaS, bounded context division rules, the four-layer DDD boundaries, clean layered, hexagonal, and onion architectures, and concludes with practical insights for building decoupled, scalable systems.
Bounded Contextdomain-driven design
0 likes · 9 min read

This article introduces Domain-Driven Design (DDD), explains key terminology, describes the evolution of architecture from SaaS to IaaS, details bounded context concepts and division rules, and reviews major architectural styles such as clean layered, hexagonal, and onion architectures for building robust software systems.
Bounded ContextDDDclean architecture
0 likes · 9 min read

This guide walks through applying Domain‑Driven Design to a brand‑new project, covering essential terminology, the evolution from SaaS to IaaS, defining bounded contexts, the four DDD boundaries, and various architectural styles such as clean layered, hexagonal, and onion architectures, with practical insights for implementation.
Bounded Contextclean architecturedomain-driven design
0 likes · 10 min read

This article explains Domain-Driven Design (DDD), outlining why it is needed, how it solves common software development problems, and detailing strategic and tactical design steps, event‑storming techniques, and common misconceptions to help teams align business and technical perspectives.
Bounded ContextEvent StormingStrategic Design
0 likes · 14 min read

This article explains how to design microservice architectures by applying domain‑driven design concepts such as bounded contexts and aggregates, using context mapping and event‑storming techniques to identify service boundaries, and discusses communication patterns, CAP trade‑offs, and the Backend‑for‑Frontend approach.
Bounded ContextEvent Stormingdomain-driven design
0 likes · 21 min read

The article explains various context‑mapping techniques from Domain‑Driven Design—such as Partnership, Shared Kernel, Customer/Supplier, Conformist, Anti‑Corruption Layer, Open Host Service, and Published Language—and advises when to apply each based on code, team, and business considerations.
Bounded ContextContext MappingIntegration Patterns
0 likes · 7 min read

This article explains how to design microservice architectures by applying Domain‑Driven Design principles, defining bounded contexts and aggregates, using context mapping and event‑storming to identify service boundaries, and addressing communication, consistency, and orchestration challenges in distributed systems.
Bounded ContextEvent Stormingservice architecture
0 likes · 20 min read

This article explains how microservice architectures differ from traditional service‑oriented designs, outlines key characteristics such as bounded contexts and autonomy, and shows how Domain‑Driven Design, context mapping, and event‑storming can be used to identify, model, and communicate clear service boundaries for resilient, scalable systems.
Bounded ContextEvent Stormingdomain-driven design
0 likes · 21 min read

This article explains how to design microservice architectures by applying domain‑driven design, defining bounded contexts, using context mapping and event‑storming techniques, and addressing communication, consistency, and integration patterns such as event‑driven messaging and the Backend‑for‑Frontend approach.
Backend For FrontendBounded ContextContext Mapping
0 likes · 19 min read

This article explains how Domain‑Driven Design (DDD) helps large‑scale systems separate business and technical complexity, using strategic and tactical patterns such as bounded contexts, layered, hexagonal and clean architectures, CQRS, and context mapping to enable rapid response to changing requirements.
Bounded ContextDDD
0 likes · 43 min read

The article explains how a universal language and bounded context in Domain‑Driven Design reduce communication loss, guide consistent terminology, and serve as the primary basis for defining microservice boundaries, illustrating concepts with examples from e‑commerce and insurance domains.
Bounded ContextDDDUniversal Language
0 likes · 11 min read

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 Contextcqrsdomain-driven design
0 likes · 41 min read

This article explains how to use ContextMapper's DSL to express Domain‑Driven Design concepts—such as strategic and tactical design, subdomains, bounded contexts, context maps, user stories, and use cases—through concrete code examples, illustrating the benefits for architecture standardization and microservice integration.
Bounded ContextContextMapperDSL
0 likes · 21 min read


JavaEdgeSep 30, 2020 · Backend Development
This article explains how defining bounded contexts and establishing a ubiquitous language during event‑storming sessions ensures clear, consistent terminology that maps directly to domain objects and code, guiding accurate microservice design and implementation.
Bounded ContextDDDEvent Storming
0 likes · 7 min read

The article demonstrates how applying Domain‑Driven Design to a lottery platform’s microservices—by defining bounded contexts such as lottery and risk control, modeling aggregates like DrawLottery and AwardPool, using domain services and anti‑corruption layers, and enforcing high cohesion and low coupling—solves over‑coupling and anemic domain model challenges while tightly aligning the system with business logic.
Bounded ContextDDDaggregates
0 likes · 28 min read
