BestHub
Sign in
Tagged articles
302 articles
Page 3 of 4
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 17, 2021 · Fundamentals

Why Domain-Driven Design (DDD) Became Popular and Its Role in Microservices

The article explains how Domain-Driven Design (DDD) rose to prominence by addressing business‑boundary challenges in microservice architectures, outlines the evolution of software architectures, and details DDD’s strategic and tactical design practices for creating clear, maintainable service boundaries.

DDDDomain-Driven DesignSoftware Architecture
0 likes · 9 min read
Why Domain-Driven Design (DDD) Became Popular and Its Role in Microservices
Architecture Digest
Architecture Digest
Oct 12, 2021 · Fundamentals

Introduction to Domain-Driven Design (DDD)

This article provides a concise overview of Domain-Driven Design, explaining why it matters, defining key concepts such as domain, model, bounded context, and ubiquitous language, and illustrating how DDD helps teams tackle core software complexity through collaborative modeling and shared terminology.

DDDDomain-Driven DesignSoftware Architecture
0 likes · 11 min read
Introduction to Domain-Driven Design (DDD)
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
Java High-Performance Architecture
Java High-Performance Architecture
Oct 6, 2021 · Backend Development

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

This article details how a legacy e‑commerce supply‑chain system was re‑architected using Domain‑Driven Design, Hexagonal architecture, CQRS, and an EventStore solution to resolve unclear boundaries, inventory inaccuracies, and scalability issues while improving testability and operational efficiency.

Backend ArchitectureDDDEvent Sourcing
0 likes · 8 min read
How DDD and Event Sourcing Revamped a Legacy Supply‑Chain System
Architect
Architect
Oct 5, 2021 · Fundamentals

Understanding Entities and Value Objects in Domain‑Driven Design: Why a Message Should Be an Entity and Contacts Should Be Treated as Entities

The article explains the core characteristics of entities—identity and continuity—using DDD concepts, demonstrates why a Message in a messaging scenario qualifies as an entity, and argues that senders and recipients (contacts) should also be modeled as entities rather than value objects.

DDDDomain-Driven DesignEntity
0 likes · 12 min read
Understanding Entities and Value Objects in Domain‑Driven Design: Why a Message Should Be an Entity and Contacts Should Be Treated as Entities
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.

Backend ArchitectureDDDEvent Sourcing
0 likes · 10 min read
How DDD and Event Sourcing Revamped a Legacy Supply‑Chain System
Top Architect
Top Architect
Sep 28, 2021 · Backend Development

Applying Domain‑Driven Design to Refactor Keep's E‑commerce Supply Chain System

This article describes how Keep leveraged Domain‑Driven Design, hexagonal architecture, CQRS and EventStore to restructure a legacy supply‑chain system, solve inventory inaccuracies, improve modularity, and achieve scalable, maintainable backend services for its e‑commerce platform.

Backend ArchitectureDDDDomain-Driven Design
0 likes · 7 min read
Applying Domain‑Driven Design to Refactor Keep's E‑commerce Supply Chain System
YunZhu Net Technology Team
YunZhu Net Technology Team
Sep 23, 2021 · Backend Development

ABP vNext Framework: Overview, Features, and Step‑by‑Step Guide to Building a .NET Microservice Application

This article introduces the ABP vNext framework, explains its origins from ASP.NET Boilerplate, details its modular, DDD‑based architecture and microservice capabilities, and provides a complete hands‑on tutorial—including CLI commands, project structure, code snippets, and best‑practice recommendations—for creating a .NET microservice solution.

ABPBackend DevelopmentDDD
0 likes · 17 min read
ABP vNext Framework: Overview, Features, and Step‑by‑Step Guide to Building a .NET Microservice Application
ByteFE
ByteFE
Sep 15, 2021 · Frontend Development

Why DDD Is Needed and How to Apply Domain-Driven Design in Front‑End Projects

The article explains the need for Domain‑Driven Design (DDD) to manage growing complexity caused by frequent requirement changes, describes DDD fundamentals such as bounded contexts and event storming, and shows how to structure React front‑end code, actions, reducers, and routing by organizing features to reduce coupling and improve maintainability.

DDDDomain-Driven DesignEvent Storming
0 likes · 11 min read
Why DDD Is Needed and How to Apply Domain-Driven Design in Front‑End Projects
IT Architects Alliance
IT Architects Alliance
Sep 12, 2021 · Fundamentals

Fundamentals of Domain‑Driven Design: Core Concepts, Building Blocks, and Architectural Patterns

This article introduces the essential principles of Domain‑Driven Design, explaining its two‑stage approach, key building blocks such as entities, value objects, aggregates, factories, repositories, services, and domain events, and shows how DDD fits into layered architecture and common anti‑patterns.

AggregatesDDDDomain-Driven Design
0 likes · 26 min read
Fundamentals of Domain‑Driven Design: Core Concepts, Building Blocks, and Architectural Patterns
Architects Research Society
Architects Research Society
Sep 5, 2021 · Fundamentals

An Introduction to Domain-Driven Design (DDD) Patterns and Practices

This article explains the core concepts, patterns, and architectural styles of Domain-Driven Design, covering model‑driven design, bounded contexts, layered and hexagonal architectures, building blocks such as entities, value objects, aggregates, repositories, factories, and services, with practical examples and diagrams.

BackendDDDDomain-Driven Design
0 likes · 28 min read
An Introduction to Domain-Driven Design (DDD) Patterns and Practices
DevOps
DevOps
Aug 31, 2021 · Backend Development

Designing an Uber‑Like Microservice System with DDD, OpenTelemetry Observability, and Reinforced Chaos Engineering

This article describes how to model a complex Uber‑style ride‑hailing system using Domain‑Driven Design, implement it with Java Spring Boot microservices, instrument it with OpenTelemetry for full observability, and validate the observability pipeline through a gamified chaos‑engineering approach that reduces MTTR.

DDDJavaMicroservices
0 likes · 13 min read
Designing an Uber‑Like Microservice System with DDD, OpenTelemetry Observability, and Reinforced Chaos Engineering
IT Architects Alliance
IT Architects Alliance
Aug 16, 2021 · Backend Development

Applying Layered Architecture and DDD to Microservice System Design

The article presents a practical approach to designing complex microservice systems by combining layered architecture with Domain‑Driven Design, outlining a five‑layer model, detailing each layer’s responsibilities, offering domain‑splitting guidelines, and illustrating implementation with code examples and development steps.

DDDMicroservicesSoftware Engineering
0 likes · 25 min read
Applying Layered Architecture and DDD to Microservice System Design
dbaplus Community
dbaplus Community
Aug 9, 2021 · Backend Development

Applying Domain‑Driven Design in Haro’s Transaction Platform: Key Lessons

This article explains the fundamentals of Domain‑Driven Design (DDD), outlines its strategic and tactical design processes, and demonstrates how Haro’s transaction platform applies DDD across taxi, e‑commerce, and core trading scenarios, highlighting benefits, challenges, and practical recommendations.

Backend DevelopmentDDDDomain-Driven Design
0 likes · 29 min read
Applying Domain‑Driven Design in Haro’s Transaction Platform: Key Lessons
Programmer DD
Programmer DD
Aug 6, 2021 · Backend Development

How Domain‑Driven Design Powers Scalable Microservices Architecture

This article explains how Domain‑Driven Design provides a systematic approach to modeling complex business domains, guiding microservice decomposition, service boundaries, bounded contexts, and layered architectures, while addressing software complexity through strategic and tactical patterns such as SOLID, aggregates, and hexagonal design.

Backend ArchitectureDDDDomain-Driven Design
0 likes · 19 min read
How Domain‑Driven Design Powers Scalable Microservices Architecture
Ctrip Technology
Ctrip Technology
Aug 5, 2021 · Backend Development

Applying Domain-Driven Design and Hexagonal Architecture in Ctrip International Train Ticket Booking System

This article presents a practical implementation of Domain-Driven Design (DDD) and hexagonal architecture in Ctrip's international train ticket booking platform, detailing strategic and tactical design, addressing controller bloat, over‑coupling, and anemic models, and showcasing Java code examples for aggregates, repositories, and factories.

DDDDomain ModelingHexagonal Architecture
0 likes · 17 min read
Applying Domain-Driven Design and Hexagonal Architecture in Ctrip International Train Ticket Booking System
IT Architects Alliance
IT Architects Alliance
Aug 4, 2021 · Fundamentals

Layered Architecture: Strict, Relaxed, and Inheritance‑Based Approaches

The article explains the concepts, rules, and evolution of layered architecture—including strict layering, relaxed layering, and inheritance‑based layering—while illustrating practical implementations with Java code and discussing how front‑end separation and DDD influence architectural decisions.

Architecture PatternsBackendDDD
0 likes · 8 min read
Layered Architecture: Strict, Relaxed, and Inheritance‑Based Approaches
ByteDance Web Infra
ByteDance Web Infra
Jul 23, 2021 · Backend Development

Design and Refactoring of ByteDance's Node.js RPC Framework

This article explains the motivation, design principles, model architecture, and implementation challenges of rebuilding ByteDance's Node.js RPC system, covering DDD‑based decomposition, protocol and connection abstractions, multi‑protocol nesting, client/server creation APIs, and performance‑optimized context extensions.

Backend DevelopmentDDDNode.js
0 likes · 14 min read
Design and Refactoring of ByteDance's Node.js RPC Framework
Miss Fresh Tech Team
Miss Fresh Tech Team
Jul 7, 2021 · Backend Development

How DDD Transforms Complex Store Systems: From Monolith to Scalable Microservices

This article explores how Domain‑Driven Design (DDD) was applied to redesign a rapidly evolving retail store system, detailing the challenges of legacy monoliths, the step‑by‑step migration through versions 1.0, 2.0 and 3.0, and the resulting architectural, tactical and operational benefits for backend development.

Backend ArchitectureDDDDomain-Driven Design
0 likes · 41 min read
How DDD Transforms Complex Store Systems: From Monolith to Scalable Microservices
ITFLY8 Architecture Home
ITFLY8 Architecture Home
Jul 1, 2021 · Fundamentals

What a Peach Tree Can Teach You About Domain‑Driven Design

This article uses a peach‑tree analogy to explain how to break down complex business logic into domains, subdomains, core, generic, and supporting domains, illustrating the practical steps and benefits of applying Domain‑Driven Design in software projects.

DDDDomain ModelingMicroservices
0 likes · 8 min read
What a Peach Tree Can Teach You About Domain‑Driven Design
Architecture Digest
Architecture Digest
Jun 28, 2021 · Backend Development

Why Domain-Driven Design (DDD) Became Popular and How It Solves Microservice Boundary Challenges

The article explains the rise of Domain-Driven Design by tracing architectural evolution from monolithic to microservices, highlighting DDD’s role in defining business boundaries, its strategic and tactical components, and practical steps for modeling domains to guide microservice design.

Backend DevelopmentDDDDomain-Driven Design
0 likes · 11 min read
Why Domain-Driven Design (DDD) Became Popular and How It Solves Microservice Boundary Challenges
Alibaba Cloud Developer
Alibaba Cloud Developer
Jun 22, 2021 · Backend Development

Mastering DDD Aggregates: When and How to Define Boundaries

This article explains the purpose of aggregates in Domain‑Driven Design, illustrates common pitfalls with database‑centric and naïve OO models, and provides practical heuristics and implementation guidelines—including lifecycle, domain, and scenario consistency—to help developers design clean, consistent aggregates.

AggregatesBackend ArchitectureDDD
0 likes · 22 min read
Mastering DDD Aggregates: When and How to Define Boundaries
Alibaba Cloud Developer
Alibaba Cloud Developer
Jun 16, 2021 · Backend Development

Mastering DDD Aggregates: Defining Boundaries for Consistent Design

This article explains the essence of DDD aggregates, why they are needed to enforce business consistency, how to identify proper aggregate boundaries using lifecycle, domain, and scenario‑frequency rules, and provides practical implementation guidance with code examples and architectural tips.

AggregatesBackend ArchitectureDDD
0 likes · 22 min read
Mastering DDD Aggregates: Defining Boundaries for Consistent Design
Top Architect
Top Architect
Jun 14, 2021 · Backend Development

Microservice Communication: RPC vs Event‑Driven, Event Sourcing, and Design Strategies

The article examines microservice communication methods, comparing RPC and event‑driven approaches, explains different coupling types, introduces event notification and event sourcing, discusses API gateways, service composition, internal microservice design, and offers practical guidance for reducing tight coupling and managing service scale.

API-gatewayDDDEvent-driven
0 likes · 19 min read
Microservice Communication: RPC vs Event‑Driven, Event Sourcing, and Design Strategies
Alibaba Cloud Developer
Alibaba Cloud Developer
Jun 7, 2021 · Fundamentals

Why Domain Models Are the Secret Weapon for Stable, Scalable Software

This article explains the concept of domain models, why they are crucial business assets, how to create and use them with UML diagrams and simple examples, highlights common misconceptions, and shows how explicit modeling improves communication, code readability, and software adaptability.

DDDDomain ModelingSoftware Architecture
0 likes · 16 min read
Why Domain Models Are the Secret Weapon for Stable, Scalable Software
Architecture Digest
Architecture Digest
May 25, 2021 · Backend Development

Layered Architecture and Domain‑Driven Design for Java Fresh‑Food E‑Commerce Microservices

This article presents a practical approach to applying layered architecture and Domain‑Driven Design (DDD) in a Java‑based fresh‑food e‑commerce platform, outlining a five‑layer microservice structure, domain partitioning guidelines, and common pitfalls to help teams build maintainable, scalable systems.

DDDJavae‑commerce
0 likes · 18 min read
Layered Architecture and Domain‑Driven Design for Java Fresh‑Food E‑Commerce Microservices
Qunar Tech Salon
Qunar Tech Salon
May 20, 2021 · Backend Development

Rebuilding a Hotel Pricing Engine with Domain-Driven Design: A Qunar Case Study

The article describes how Qunar's technical director Zheng Jimin applied Domain‑Driven Design to refactor the hotel pricing engine, dramatically improving development efficiency, reducing onboarding time, and aligning product and engineering through a three‑stage strategic, tactical, and implementation process.

DDDDomain-Driven DesignHotel Pricing Engine
0 likes · 7 min read
Rebuilding a Hotel Pricing Engine with Domain-Driven Design: A Qunar Case Study
Alibaba Cloud Developer
Alibaba Cloud Developer
May 17, 2021 · Fundamentals

Why OOP Struggles with Complex Game Logic and How DDD/ECS Help

This article examines the limitations of classic object‑oriented programming for intricate game rules, demonstrates a dragon‑and‑magic example, compares OOP, Entity‑Component‑System and Domain‑Driven Design approaches, and provides practical guidelines, code snippets, and design patterns to achieve extensible, maintainable architecture.

DDDDesign PatternsECS
0 likes · 39 min read
Why OOP Struggles with Complex Game Logic and How DDD/ECS Help
JD Retail Technology
JD Retail Technology
May 11, 2021 · Backend Development

Redesigning JD's C‑End Invoice System: Architecture Upgrade, Performance Optimizations, and Future Roadmap

The article details JD's transition from a fragmented C‑end invoice service to a unified Invoice Center, describing the original user‑experience and architectural flaws, the DDD‑based layered redesign, performance‑boosting data and file‑handling strategies, achieved operational gains, and the planned next‑year initiatives.

DDDdata storageinvoice system
0 likes · 10 min read
Redesigning JD's C‑End Invoice System: Architecture Upgrade, Performance Optimizations, and Future Roadmap
Alibaba Cloud Developer
Alibaba Cloud Developer
Apr 28, 2021 · Backend Development

How to Refactor Monolithic Checkout Code into Clean DDD Modules

This article explains how to identify and refactor typical “流水账” (spaghetti) code in a checkout API by applying Domain‑Driven Design layers—splitting responsibilities into Interface, Application, and Domain layers, using CQE objects, DTO assemblers, and anti‑corruption facades to achieve clear, maintainable modules.

Anti‑Corruption LayerCQEDDD
0 likes · 32 min read
How to Refactor Monolithic Checkout Code into Clean DDD Modules
Baidu Geek Talk
Baidu Geek Talk
Apr 28, 2021 · Fundamentals

DDD Practice and Exploration at Baidu Aifanfan

The article recounts Baidu Aifanfan’s year‑long journey of exploring, promoting, and fully implementing Domain‑Driven Design—addressing Chinese developers’ limited DDD exposure, illustrating its fit with micro‑service and platform architectures, and offering practical insights on its value, suitable projects, team requirements, and impact on development practices.

DDDDomain-Driven DesignProduct Development
0 likes · 23 min read
DDD Practice and Exploration at Baidu Aifanfan
phodal
phodal
Apr 19, 2021 · Fundamentals

Unlocking Pattern Languages: From Design Patterns to Architecture

This article explores the concept of patterns and pattern languages across software design, architecture, and domain-driven design, detailing their definitions, classifications, practical usage, and examples such as POSA, microservice patterns, and elemental design patterns to help engineers systematically solve recurring problems.

DDDDesign PatternsPOSA
0 likes · 13 min read
Unlocking Pattern Languages: From Design Patterns to Architecture
IT Architects Alliance
IT Architects Alliance
Apr 10, 2021 · Backend Development

DDD Layered Architecture Patterns: Four‑Layer, Five‑Layer, and Hexagonal Approaches

This article reviews the fundamentals of Domain‑Driven Design and layered architecture, explains the role of ubiquitous language and bounded contexts, and compares three classic DDD layering patterns—four‑layer, five‑layer, and hexagonal—highlighting their practical definitions, benefits, drawbacks, and evolution for microservice‑based systems.

DDDsoftware design
0 likes · 19 min read
DDD Layered Architecture Patterns: Four‑Layer, Five‑Layer, and Hexagonal Approaches
Architect
Architect
Apr 8, 2021 · Fundamentals

Understanding Layered Architecture: Strict, Relaxed, and Inheritance Approaches

The article explains various layered architecture models—including strict, relaxed, and inheritance‑based approaches—detailing their coupling rules, implementation guidelines, code examples, and evolution through multi‑layered system designs, especially within domain‑driven design and modern front‑back separation.

Architecture PatternsBackendDDD
0 likes · 8 min read
Understanding Layered Architecture: Strict, Relaxed, and Inheritance Approaches
DeWu Technology
DeWu Technology
Mar 26, 2021 · Backend Development

Summary of DDD Layered Architecture for the Bidding Team

The Bidding Team’s DDD layered architecture consolidates all traffic in an Interfaces layer, uses a thin Application service layer to orchestrate use‑cases, places core business rules in Domain aggregates, isolates data access in Infrastructure, adds an Anti‑Corruption adapter, and employs DTOs, entities, and domain events for decoupled, consistent processing.

Anti‑Corruption LayerDDDDomain-Driven Design
0 likes · 12 min read
Summary of DDD Layered Architecture for the Bidding Team
DevOps
DevOps
Mar 26, 2021 · Fundamentals

From Software Engineering to Enterprise Architecture: Evolution of Design Methodologies and the Role of EBA and the Middle Platform

This article traces the evolution of software engineering and enterprise architecture, reviewing classic models like Waterfall, Zachman, TOGAF, Agile, DDD, and microservices, and examines how Enterprise Business Architecture (EBA) and the middle‑platform concept serve as integrative frameworks for modern digital transformation.

DDDEBAMicroservices
0 likes · 36 min read
From Software Engineering to Enterprise Architecture: Evolution of Design Methodologies and the Role of EBA and the Middle Platform
IT Architects Alliance
IT Architects Alliance
Mar 22, 2021 · Backend Development

Why Microservices Need DDD: Solving Complexity in Modern Systems

The article examines the limitations of microservice architectures, explains how Domain‑Driven Design (DDD) complements them by providing functional decomposition guidance, and presents a practical case study showing how clear bounded contexts and aggregate roots enable scalable, maintainable system splits.

DDDDomain-Driven DesignMicroservices
0 likes · 9 min read
Why Microservices Need DDD: Solving Complexity in Modern Systems
Architecture Digest
Architecture Digest
Mar 22, 2021 · Fundamentals

DDD Layered Architecture: Four‑Layer, Five‑Layer, and Hexagonal Patterns

This article reviews Domain‑Driven Design and layered architecture fundamentals, then explains three classic DDD layered patterns—four‑layer, five‑layer, and hexagonal architectures—detailing their layers, responsibilities, advantages, drawbacks, and practical adaptations for microservice development.

DDDHexagonal ArchitectureMicroservices
0 likes · 21 min read
DDD Layered Architecture: Four‑Layer, Five‑Layer, and Hexagonal Patterns
Yanxuan Tech Team
Yanxuan Tech Team
Mar 19, 2021 · Backend Development

How DDD Can Rescue a Decaying Warehouse Management System

This article examines the chronic decay of a complex warehouse inbound/outbound system, analyzes its tangled business logic and chaotic architecture, and presents a domain‑driven design solution with onion architecture, CQRS, and practical implementation steps to achieve clearer boundaries, higher cohesion, and sustainable evolution.

Backend DevelopmentCQRSDDD
0 likes · 15 min read
How DDD Can Rescue a Decaying Warehouse Management System
Architect
Architect
Mar 17, 2021 · Fundamentals

Understanding Domains, Subdomains, and Core Domains in Domain-Driven Design

This article explains the distinction between technical and business domains, defines domains and subdomains, describes how to identify core, generic, and supporting subdomains, and outlines practical methods such as domain vision statements and highlighted cores for effective domain‑driven design.

Core DomainDDDDomain-Driven Design
0 likes · 10 min read
Understanding Domains, Subdomains, and Core Domains in Domain-Driven Design
Alibaba Terminal Technology
Alibaba Terminal Technology
Mar 3, 2021 · Frontend Development

How We Solved Complex Frontend Data Flow with MobX and DDD

Facing tangled data flow, excessive template code, and scaling challenges in a large single‑page app, we analyzed business traits, identified pain points, and redesigned the architecture using layered stores, an API anti‑corruption layer, and domain‑driven design with MobX, achieving simpler, reusable, and maintainable front‑end code.

DDDData FlowMobX
0 likes · 12 min read
How We Solved Complex Frontend Data Flow with MobX and DDD
Architecture Digest
Architecture Digest
Mar 3, 2021 · Backend Development

Integrating Domain‑Driven Design with Microservices: Benefits, Drawbacks, and Practical Guidance

This article explains how Domain‑Driven Design complements microservice architecture by addressing functional partitioning, clarifying bounded contexts, and improving scalability, while also discussing microservice drawbacks and practical guidelines for splitting complex systems in modern applications.

Backend ArchitectureDDDDomain Modeling
0 likes · 9 min read
Integrating Domain‑Driven Design with Microservices: Benefits, Drawbacks, and Practical Guidance
Selected Java Interview Questions
Selected Java Interview Questions
Jan 19, 2021 · Backend Development

Designing a Monolithic Application for Future Microservice Migration: Best Practices and Code Structure

The article explains how to design a monolithic Java application with clear business boundaries, modular code organization, MVC layering, and disciplined controller logic so that it can be smoothly refactored into a micro‑service architecture, illustrating the approach with directory trees, package schemes, and sample CommonResult code.

DDDJavaMVC
0 likes · 11 min read
Designing a Monolithic Application for Future Microservice Migration: Best Practices and Code Structure
Qunar Tech Salon
Qunar Tech Salon
Jan 12, 2021 · Backend Development

Qunar 2020 Technical Article Collection: DDD, API, Backend, Infrastructure and System Design

This compilation presents Qunar's 2020 technical articles covering domain‑driven design, API standardization, backend services, Linux I/O, Redis distributed locks, GraphQL, JVM internals, and performance optimizations, offering detailed insights and practical guidance for engineers seeking to improve system architecture and operational efficiency.

APIBackendDDD
0 likes · 8 min read
Qunar 2020 Technical Article Collection: DDD, API, Backend, Infrastructure and System Design
iQIYI Technical Product Team
iQIYI Technical Product Team
Jan 8, 2021 · Backend Development

Domain-Driven Design (DDD) Practice in a Reward Service: Architecture, Strategic and Tactical Design

Applying Domain‑Driven Design and Hexagonal architecture to a reward service clarified domain boundaries, cut integration, middleware and onboarding costs by up to 30 %, streamlined unit‑test creation, and enabled a layered, framework‑independent codebase with entities, value objects, services, events, aggregates and factories that improve maintainability, scalability and testability.

Backend DevelopmentDDDDomain-Driven Design
0 likes · 15 min read
Domain-Driven Design (DDD) Practice in a Reward Service: Architecture, Strategic and Tactical Design
Qunar Tech Salon
Qunar Tech Salon
Dec 29, 2020 · Backend Development

Qunar's API Standardization: From DDD to API Governance and QDoc Implementation

This article describes Qunar's comprehensive API standardization effort, detailing the evolution of their API tools, the motivations behind adopting DDD and API governance, the theoretical foundations, the QDoc annotation framework, implementation steps, challenges faced, achieved outcomes, and future plans for continuous improvement.

APIBackendDDD
0 likes · 18 min read
Qunar's API Standardization: From DDD to API Governance and QDoc Implementation
Qunar Tech Salon
Qunar Tech Salon
Dec 2, 2020 · Backend Development

Applying Domain-Driven Design to Refactor a Hotel Pricing System

This article describes how a hotel pricing platform was refactored using Domain-Driven Design, detailing the strategic, tactical, and implementation phases that clarified domain boundaries, introduced a layered architecture, standardized processes, and delivered faster development, better maintainability, and improved operational visibility.

Backend ArchitectureDDDDomain-Driven Design
0 likes · 14 min read
Applying Domain-Driven Design to Refactor a Hotel Pricing System
IT Architects Alliance
IT Architects Alliance
Nov 10, 2020 · Backend Development

Designing a Layered Microservice Architecture with DDD for Java E‑Commerce Platforms

This article presents a practical approach to applying layered architecture and Domain‑Driven Design (DDD) to a Java‑based fresh‑food e‑commerce microservice system, outlining five layers, their responsibilities, design principles, domain partitioning tips, and common pitfalls to help engineers build maintainable, scalable back‑ends.

DDDJavaSoftware Engineering
0 likes · 20 min read
Designing a Layered Microservice Architecture with DDD for Java E‑Commerce Platforms
ITFLY8 Architecture Home
ITFLY8 Architecture Home
Nov 7, 2020 · Backend Development

How to Layer Microservices with DDD for Scalable Java E‑Commerce

This article explains a practical approach to applying layered architecture and Domain‑Driven Design (DDD) to a Java microservice‑based fresh‑food e‑commerce platform, outlining five architectural layers, domain service partitioning, common pitfalls, and guidance for building maintainable, high‑cohesion services.

DDDMicroservicese‑commerce
0 likes · 18 min read
How to Layer Microservices with DDD for Scalable Java E‑Commerce
ITFLY8 Architecture Home
ITFLY8 Architecture Home
Nov 2, 2020 · Backend Development

How Domain‑Driven Design Can Tame Complex Business Logic in High‑Scale Systems

This article explains how the Tongtian Tower platform adopted Domain‑Driven Design to separate business and technical complexity, improve scalability, and enable rapid response to changing requirements through strategic and tactical design, bounded contexts, hexagonal and clean architectures, and related patterns such as CQRS and microservices.

DDDDomain-Driven Designarchitecture
0 likes · 43 min read
How Domain‑Driven Design Can Tame Complex Business Logic in High‑Scale Systems
HomeTech
HomeTech
Oct 28, 2020 · Backend Development

Design and Implementation of a Scalable Generic Lottery System

This article describes the design, domain‑driven architecture, probability algorithms, extensibility mechanisms, concurrency controls, and management UI of a reusable lottery platform that supports high‑traffic promotional activities while ensuring configurability, anti‑cheat measures, and reliable data consistency.

DDDLottery
0 likes · 12 min read
Design and Implementation of a Scalable Generic Lottery System
JavaEdge
JavaEdge
Oct 13, 2020 · Backend Development

How DDD Layered Architecture Transforms Microservices Design

This article explains the principles, types, and layer responsibilities of DDD layered architecture, compares it with traditional four‑layer and three‑layer designs, and shows how microservices can evolve by reorganizing aggregates and applying dependency inversion across UI, application, domain, and infrastructure layers.

DDDMicroservicesbackend design
0 likes · 14 min read
How DDD Layered Architecture Transforms Microservices Design
JavaEdge
JavaEdge
Oct 11, 2020 · Backend Development

What Are Aggregates, Roots, Entities, and Value Objects in DDD?

This article explains DDD aggregates, aggregate roots, entities and value objects, shows how to model them with event‑storming, illustrates e‑commerce and insurance examples, discusses design principles such as small aggregates, consistency boundaries, and cross‑aggregate communication.

AggregatesDDDDomain Modeling
0 likes · 14 min read
What Are Aggregates, Roots, Entities, and Value Objects in DDD?
JavaEdge
JavaEdge
Oct 3, 2020 · Fundamentals

Why Value Objects Matter in DDD: Benefits, Traits, and DB Simplification

This article explains why value objects are essential in Domain‑Driven Design, outlines their defining characteristics, shows practical modeling examples, compares different implementation forms, and demonstrates how they can simplify database design while highlighting their advantages and pitfalls.

BackendDDDDomain Modeling
0 likes · 11 min read
Why Value Objects Matter in DDD: Benefits, Traits, and DB Simplification
JavaEdge
JavaEdge
Sep 30, 2020 · Backend Development

How Bounded Context and Ubiquitous Language Shape Precise Microservice Design

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
How Bounded Context and Ubiquitous Language Shape Precise Microservice Design
Top Architect
Top Architect
Aug 26, 2020 · Fundamentals

Applying Domain‑Driven Design to Microservice Architecture: Benefits, Drawbacks, and Splitting Strategies

The article explains how Domain‑Driven Design (DDD) complements microservice architecture by addressing functional partitioning, clarifying bounded contexts, and guiding service decomposition, while also highlighting microservices' shortcomings in handling requirement changes and offering practical guidelines for effective system splitting.

DDDDomain ModelingService Splitting
0 likes · 10 min read
Applying Domain‑Driven Design to Microservice Architecture: Benefits, Drawbacks, and Splitting Strategies
Suning Technology
Suning Technology
Aug 14, 2020 · Big Data

Building SuNing’s Supply‑Chain Data Platform with DDD and Big‑Data Design

This article recounts SuNing’s step‑by‑step journey of designing and implementing a supply‑chain data middle platform, outlining its business rationale, DDD‑based domain modeling, layered system architecture, and practical deployment insights that illustrate how a tailored big‑data solution can enhance data services and governance.

Big DataDDDData Governance
0 likes · 11 min read
Building SuNing’s Supply‑Chain Data Platform with DDD and Big‑Data Design
360 Tech Engineering
360 Tech Engineering
Jun 1, 2020 · Backend Development

Building a Food Recommendation API with Domain‑Driven Design in Go

This tutorial walks through a complete Golang implementation of a food‑recommendation API using Domain‑Driven Design (DDD), covering the four DDD layers, entity and repository definitions, persistence setup with Gorm, application services, HTTP interfaces, middleware, and how to run the service.

APIBackendDDD
0 likes · 28 min read
Building a Food Recommendation API with Domain‑Driven Design in Go
Full-Stack Internet Architecture
Full-Stack Internet Architecture
Mar 2, 2020 · Backend Development

Reflections on Transaction System Design: Principles, Paradigms, and Patterns

This article reflects on the redesign of a high‑traffic transaction system, discussing the decision‑making process, programming paradigms, SOLID principles, domain‑driven design, component decomposition, and the evolution from simple state machines to flexible, maintainable backend architectures.

Backend DevelopmentDDDMicroservices
0 likes · 21 min read
Reflections on Transaction System Design: Principles, Paradigms, and Patterns
21CTO
21CTO
Nov 16, 2019 · Fundamentals

Why Strategic Design, Not Just Tactical, Is the True Heart of DDD

In this article, Meituan‑Dianping expert Mu Zongyan’s GIAC conference talk highlights that while Domain‑Driven Design has become popular with microservices, its true power lies in strategic design rather than rigid tactical patterns, urging architects to focus on broader business contexts.

DDDDomain-Driven DesignSoftware Architecture
0 likes · 4 min read
Why Strategic Design, Not Just Tactical, Is the True Heart of DDD
Architects Research Society
Architects Research Society
Oct 10, 2019 · Fundamentals

An Introduction to Domain-Driven Design Patterns and Practices

This article explains the core concepts of Domain‑Driven Design, including model‑driven design, ubiquitous language, bounded contexts, layered and hexagonal architectures, and key building blocks such as entities, value objects, aggregates, repositories, factories, and services, to help developers build business‑centric enterprise applications.

DDDDomain-Driven DesignHexagonal Architecture
0 likes · 22 min read
An Introduction to Domain-Driven Design Patterns and Practices
Programmer DD
Programmer DD
Aug 16, 2019 · Backend Development

Designing a Scalable Microservice E‑Commerce System with DDD, Distributed Transactions, and Resilience

This article walks through the complete design of an e‑commerce microservice architecture, covering module identification, domain‑driven design, service splitting, technology stack choices between Dubbo and Spring Cloud, distributed transaction patterns, resilience with Hystrix, centralized configuration, and observability with SkyWalking.

DDDDistributed TransactionsHystrix
0 likes · 27 min read
Designing a Scalable Microservice E‑Commerce System with DDD, Distributed Transactions, and Resilience
Youzan Coder
Youzan Coder
Jul 31, 2019 · Backend Development

Designing a Retail Financial Middle Platform: From Business Architecture to Microservices

This article examines the challenges of traditional retail accounting, introduces the concept of a financial middle platform, outlines its business and application architecture using the C4 model, and provides practical guidance for evolving the design into a micro‑service ecosystem while balancing complexity and performance.

DDDMicroservicesRetail Architecture
0 likes · 17 min read
Designing a Retail Financial Middle Platform: From Business Architecture to Microservices
Mafengwo Technology
Mafengwo Technology
Jul 11, 2019 · Backend Development

How DDD Transformed Our E‑Commerce Discount Center: A Practical Refactor

This article details how applying Domain‑Driven Design to a complex e‑commerce discount system clarified business logic, improved flexibility, and guided a step‑by‑step architectural overhaul from a monolithic model to a layered, domain‑centric solution with tactical and strategic design considerations.

Backend RefactoringDDDDomain-Driven Design
0 likes · 17 min read
How DDD Transformed Our E‑Commerce Discount Center: A Practical Refactor
MaGe Linux Operations
MaGe Linux Operations
Jul 1, 2019 · Backend Development

Designing a Scalable E‑Commerce System with Microservices, DDD, and Distributed Transactions

This article walks through building an e‑commerce platform using microservices, covering module decomposition, domain‑driven design, service splitting, technology stack choices, distributed transaction strategies, circuit‑breaker patterns, centralized configuration, monitoring, and capacity planning to guide developers from concept to deployment.

CAP theoremDDDDistributed Systems
0 likes · 27 min read
Designing a Scalable E‑Commerce System with Microservices, DDD, and Distributed Transactions
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
ITFLY8 Architecture Home
ITFLY8 Architecture Home
Apr 13, 2019 · Frontend Development

Simplify Insurance Order Sales with Micro‑Frontends: Reduce Complexity

By applying micro‑frontend principles and DDD‑based microservice design, the article explains how insurance companies can build modular, reusable front‑end components that integrate with backend middle‑platform services, thereby lowering integration complexity, improving scalability, and enabling unified, cross‑product order sales across multiple channels.

DDDFrontend IntegrationInsurance
0 likes · 22 min read
Simplify Insurance Order Sales with Micro‑Frontends: Reduce Complexity
Programmer DD
Programmer DD
Dec 10, 2018 · Backend Development

How to Persist DDD Aggregates with JPA, Hibernate, and MongoDB

This tutorial walks through persisting Domain‑Driven Design aggregates by first explaining aggregates and aggregate roots, then showing Java class examples, followed by practical JPA/Hibernate integration challenges and a complete MongoDB document‑store solution, highlighting trade‑offs and best practices.

AggregatesDDDHibernate
0 likes · 14 min read
How to Persist DDD Aggregates with JPA, Hibernate, and MongoDB
JD Tech
JD Tech
May 9, 2018 · Cloud Native

Deep Dive into JD.com Microservice Component Platform and Its Cloud‑Native Architecture

An extensive overview of JD.com's microservice component platform explains its underlying architecture, communication technologies, service mesh (ContainerMesh), design tools based on DDD, service evaluation, migration challenges, and the platform's evolution toward a cloud‑native, self‑evolving ecosystem supporting distributed tracing, API gateways, and plugin‑based development.

DDDDistributed TracingMicroservices
0 likes · 17 min read
Deep Dive into JD.com Microservice Component Platform and Its Cloud‑Native Architecture
JD Tech
JD Tech
Apr 23, 2018 · Backend Development

Rapid Construction of the 7Fresh Retail System Using Domain‑Driven Design

The article details how JD.com’s 7Fresh retail platform was built in just two and a half months by applying strategic DDD, virtual organization structures, extensive component reuse, and cross‑team collaboration to integrate over 60 systems and dozens of devices for both online and offline operations.

BackendDDDDomain-Driven Design
0 likes · 8 min read
Rapid Construction of the 7Fresh Retail System Using Domain‑Driven Design
Alibaba Cloud Developer
Alibaba Cloud Developer
Mar 27, 2018 · Fundamentals

Why Domain Modeling Is Essential for Clean, Scalable Business Logic

This article explains why domain modeling is crucial for managing complex business logic, compares transaction scripts with domain models using a bank transfer example, outlines the benefits of object‑oriented design, and provides practical steps and best practices for building, evolving, and visualizing domain models.

DDDDomain ModelingDomain-Driven Design
0 likes · 16 min read
Why Domain Modeling Is Essential for Clean, Scalable Business Logic
dbaplus Community
dbaplus Community
Feb 5, 2018 · Backend Development

Transforming Legacy Payment Systems into Scalable Microservices: Real-World Insights

This article walks through a practical transformation of an old payment architecture into a high‑availability microservice ecosystem, covering SOA vs. microservices, DDD‑guided domain boundaries, Dubbo‑based implementation, operational challenges, continuous integration testing, and future plans for multi‑active data centers.

DDDDubboJava
0 likes · 19 min read
Transforming Legacy Payment Systems into Scalable Microservices: Real-World Insights
Meituan Technology Team
Meituan Technology Team
Dec 21, 2017 · Backend Development

Implementing Domain-Driven Design in Microservices Architecture

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.

AggregatesBounded ContextDDD
0 likes · 28 min read
Implementing Domain-Driven Design in Microservices Architecture
Alibaba Cloud Developer
Alibaba Cloud Developer
Dec 15, 2017 · Backend Development

Taming Enterprise Application Complexity: Extension Points, CQRS & DDD

Frank, a senior technical expert at Alibaba International, shares how his team tackled the growing complexity of their legacy CRM system by redesigning the architecture with extensible extension points, metadata, CQRS, DDD, SOLID principles, and disciplined layering to achieve better scalability, maintainability, and code readability.

BackendCQRSDDD
0 likes · 17 min read
Taming Enterprise Application Complexity: Extension Points, CQRS & DDD
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.

DDDDistributed SystemsEvent Sourcing
0 likes · 9 min read
Evolution of Microservice Systems Toward a Reactive Microsystem Architecture
Meituan Technology Team
Meituan Technology Team
Oct 26, 2017 · Backend Development

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

The article records a Meituan‑Dianping Q&A on Domain‑Driven Design, where engineers discuss using domain events with transactions, designing RPC interfaces, separating domain and application layers, handling cross‑aggregate operations, and defining bounded contexts, illustrating how DDD guides microservice architecture and business modeling.

CQRSDDDDomain-Driven Design
0 likes · 6 min read
Domain-Driven Design Q&A: Event Handling, Service Design, and Domain Boundaries
21CTO
21CTO
Aug 13, 2017 · Backend Development

Splitting Monoliths into Microservices with DDD: Real Cases & Tips

This article explains how to transform a classic layered monolithic architecture into microservices using Domain‑Driven Design, illustrates real‑world cases from Alibaba Cloud's EDAS platform, and shares practical best‑practice guidance on development, deployment, networking, and common microservice patterns.

Cloud NativeDDDMicroservices
0 likes · 23 min read
Splitting Monoliths into Microservices with DDD: Real Cases & Tips
ITFLY8 Architecture Home
ITFLY8 Architecture Home
Jul 5, 2017 · Backend Development

Mastering Factory Pattern and Application Layer Design for SOA Systems

This article explains the appropriate use cases for the Factory pattern, details the responsibilities and characteristics of the application layer in SOA systems, and provides concrete C# code examples for services, DTOs, and data assemblers to illustrate clean separation of concerns and effective data transfer.

Application LayerC#DDD
0 likes · 18 min read
Mastering Factory Pattern and Application Layer Design for SOA Systems
ITFLY8 Architecture Home
ITFLY8 Architecture Home
Jul 5, 2017 · Backend Development

How SOA and DDD Combine to Build Robust Backend Systems

This article explores the definitions of SOA and DDD, explains DDD's layered architecture, demonstrates how business relationships become domain models, and provides concrete C# examples of repositories, services, and factories to illustrate the integration of service‑oriented architecture with domain‑driven design.

Backend ArchitectureC#DDD
0 likes · 18 min read
How SOA and DDD Combine to Build Robust Backend Systems