Skip to content
Tagged articles

domain-driven design

409 articles · Page 1 of 5
Linyb Geek Road
Linyb Geek Road
Nov 14, 2026 · R&D Management

Five Technical Chasms to Cross from Developer to Architect

This article outlines five major technical gaps developers must bridge to become architects: shifting from monolithic to distributed thinking, mastering system design over feature coding, evolving from solo work to team collaboration, aligning technology with business strategy, and adopting cloud-native DevOps practices.

Cloud NativeDevOpsKubernetes
0 likes · 17 min read
Five Technical Chasms to Cross from Developer to Architect
Java Captain
Java Captain
Nov 14, 2026 · Backend Development

Why Java Developers Prefer Lombok Over Public Fields: Dogmatism's Toll

This article argues that Java developers adopt Lombok as a compromise against dogmatic encapsulation that mandates getters/setters for fields rarely needing custom logic, while also criticizing unnecessary interface/impl splits and DTO naming conventions, illustrated by a case where a getter enabled quick refactoring across hundreds of call sites.

BoilerplateDogmatismEncapsulation
0 likes · 4 min read
Why Java Developers Prefer Lombok Over Public Fields: Dogmatism's Toll
Architecture Breakthrough
Architecture Breakthrough
Nov 8, 2026 · Industry Insights

Six Bank Fee Types Decoded: Handling Fees, Commissions & DDD Charging Domain

This article breaks down six commercial bank fee categories — handling fees, commissions, management fees, service fees, risk commitment fees, and material fees — explaining their distinct legal nature, typical examples, and how they map to a domain-driven charging domain in banking software architecture.

bank feesbanking domain modelingcharging domain
0 likes · 9 min read
Six Bank Fee Types Decoded: Handling Fees, Commissions & DDD Charging Domain
Internet Backend Architecture Stack
Internet Backend Architecture Stack
Oct 22, 2026 · Backend Development

CQRS in Practice: Why It's Not Just Database Read/Write Separation — Domain Model Decoupling Costs & Red Lines

The article explains CQRS as domain model separation rather than database read/write splitting, detailing command/query model boundaries, event-driven synchronization challenges, consistency trade-offs, engineering pitfalls like event reliability and view explosion, when to avoid CQRS, and a reference e-commerce order implementation with consistency-based query routing.

Architecture PatternsCQRSconsistency models
0 likes · 15 min read
CQRS in Practice: Why It's Not Just Database Read/Write Separation — Domain Model Decoupling Costs & Red Lines
Internet Backend Architecture Stack
Internet Backend Architecture Stack
Oct 18, 2026 · Backend Development

Escaping the Distributed Monolith: Why Microservices Fail Without Domain Decoupling

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
Escaping the Distributed Monolith: Why Microservices Fail Without Domain Decoupling
Code Farming
Code Farming
Oct 18, 2026 · Backend Development

Four Mental Models to Deconstruct Financial Architecture

This article presents four reusable reasoning models for financial system architecture: phased FX cost optimization via netting, Boolean logic for regulatory boundary analysis, anemic vs rich domain model trade-offs for cross-module data transfer, and decomposing FX transactions into paired same-currency payments to simplify complex designs.

architectural thinkingdomain modelingdomain-driven design
0 likes · 9 min read
Four Mental Models to Deconstruct Financial Architecture
Architecture Breakthrough
Architecture Breakthrough
Oct 12, 2026 · R&D Management

How Chinese Banks' Precious Metals Offerings Deviate from Standards — and Why Paper Gold Is Disappearing

The article maps the official five-category classification of agency precious metals business against actual product lines at ICBC, China Merchants Bank, and Minsheng Bank, reveals that account precious metals (paper gold) have been phased out since 2021 due to regulatory reclassification as derivatives and the 'Oil Treasure' fallout, and contrasts paper gold with the now-favored accumulation gold across eight dimensions including leverage, physical delivery, and target users.

accumulation goldarchitecturebanking
0 likes · 13 min read
How Chinese Banks' Precious Metals Offerings Deviate from Standards — and Why Paper Gold Is Disappearing
Linyb Geek Road
Linyb Geek Road
Oct 9, 2026 · Fundamentals

Palantir Ontology Modeling: 4 Core Principles for Scalable Domain Design

This article breaks down Palantir's four prioritized ontology modeling principles—domain-driven design, DRY with Rule of Three, open/closed extension, and composition over inheritance—illustrating each with concrete anti-patterns and a practical 12-question review checklist to prevent model fragmentation as teams scale.

Composition Over InheritanceDRYData Modeling
0 likes · 20 min read
Palantir Ontology Modeling: 4 Core Principles for Scalable Domain Design
Chen Xiaogong's Room
Chen Xiaogong's Room
Oct 4, 2026 · Backend Development

Cement Platform Split: Domain Modeling, Modular Monolith vs Microservices

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 ContextCQRSarchitecture decision record
0 likes · 33 min read
Cement Platform Split: Domain Modeling, Modular Monolith vs Microservices
DeepNoMind
DeepNoMind
Oct 2, 2026 · R&D Management

From Strategy to Tactics: A Complete Software Design Methodology That Survives Production

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 ContextSaga patterncircuit breaker
0 likes · 34 min read
From Strategy to Tactics: A Complete Software Design Methodology That Survives Production
Java Tech Workshop
Java Tech Workshop
Sep 23, 2026 · Backend Development

ValidX in DDD: Layered Validation for Domain Models

This article demonstrates how ValidX, a JSR-380-compliant validation library with 100+ Chinese business validators, integrates into DDD layered architecture, showing annotation-based DTO validation, chain-style API for value objects, aggregate roots, and domain services, with code examples for each layer and best practices for avoiding common pitfalls.

Aggregate RootDDDDomain Service
0 likes · 20 min read
ValidX in DDD: Layered Validation for Domain Models
Data Bricklaying Diary
Data Bricklaying Diary
Sep 20, 2026 · Backend Development

Semantic Decoupling: What Ontology Changes Can (and Can't) Spare You From Rewriting

This article analyzes the practical limits of semantic decoupling through ontology models, showing that while field renames and stable contracts can be isolated via mapping layers, rule changes require verified data and computation, and new actions demand real execution paths — value lies in precisely scoping change impact, not promising zero development.

Anti-Corruption LayerBusiness Modelingchange impact analysis
0 likes · 24 min read
Semantic Decoupling: What Ontology Changes Can (and Can't) Spare You From Rewriting
Internet Backend Architecture Stack
Internet Backend Architecture Stack
Sep 13, 2026 · Backend Development

Microservice Governance: Service Split Extremes, Debt Triage & Strangler Fig Refactoring

This article analyzes two extremes of microservice splitting—overly coarse services that become monoliths and overly fine services that explode call chains—details a three-tier technical debt classification (P0/P1/P2), and presents a four-step Strangler Fig Pattern for zero-downtime progressive refactoring based on real e-commerce production experience.

architecture governancedomain-driven designe-commerce case study
0 likes · 13 min read
Microservice Governance: Service Split Extremes, Debt Triage & Strangler Fig Refactoring
AI Large-Model Wave and Transformation Guide
AI Large-Model Wave and Transformation Guide
Sep 9, 2026 · Industry Insights

Three-Tier Ontology Deployment Framework: Matching Solution Depth to Customer Maturity

This article presents a three-tier framework for deploying ontology products—Starter (single-scenario pilot), Growth (domain-level iteration), and Mature (enterprise semantic layer)—with criteria for tier selection, delivery methods, deliverables, team structures, commercial models, key metrics, risks, and upgrade paths, emphasizing effect-first validation and explicit gap disclosure.

customer maturity modeldeployment frameworkdomain-driven design
0 likes · 19 min read
Three-Tier Ontology Deployment Framework: Matching Solution Depth to Customer Maturity
Data Bricklaying Diary
Data Bricklaying Diary
Sep 9, 2026 · R&D Management

FDE: Converting Field Evidence into Runnable Business Models

This article explains how FDE creates a business source model from field evidence, defining roles, a five-step convergence process, traceability to engineering artifacts, and baseline release criteria, ensuring business semantics are confirmed, conflicts preserved, and models constrain implementation without replacing source systems.

Business ModelingFDEbusiness source model
0 likes · 24 min read
FDE: Converting Field Evidence into Runnable Business Models
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.

DecouplingEvent StormingMessage Queue
0 likes · 6 min read
Event Sourcing: Decouple Microservices with Domain Events
Data Bricklaying Diary
Data Bricklaying Diary
Aug 28, 2026 · Backend Development

Why Service Boundaries Fail: Aligning Business Rules, Data Ownership & Team Topology

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
Why Service Boundaries Fail: Aligning Business Rules, Data Ownership & Team Topology
Ray's Galactic Tech
Ray's Galactic Tech
Aug 24, 2026 · Backend Development

Decoupling Payments and Wallets: From Order Domain to a Unified Accounting Center

The article walks through why embedding a wallet in the order service leads to boundary violations and failures under load, and presents a step‑by‑step evolution from an order‑centric wallet to a dedicated, event‑driven accounting center that ensures consistency, auditability, and high‑throughput scalability.

IdempotencyOutbox Patternaccounting
0 likes · 42 min read
Decoupling Payments and Wallets: From Order Domain to a Unified Accounting Center
Code Farming
Code Farming
Aug 17, 2026 · Backend Development

How DDD Handles Four E‑Commerce Payment Changes Step‑by‑Step

The article walks through a real e‑commerce payment case, showing how Domain‑Driven Design models entities, uses two key questions to split responsibilities, and continuously evolves the model to accommodate discounts, VIP features, and new payment adapters, reducing code churn.

DDDSingle Responsibility Principledomain-driven design
0 likes · 6 min read
How DDD Handles Four E‑Commerce Payment Changes Step‑by‑Step
Code Farming
Code Farming
Aug 11, 2026 · Backend Development

Can DDD’s Six‑Step Method Rescue a Broken Microservices Architecture?

The article presents a real‑world case of a ride‑hailing system whose microservices became tangled, and shows how applying Domain‑Driven Design—through strategic design, a six‑step refactoring roadmap, tactical four‑layer architecture, and context mapping—can systematically restore clean, business‑driven services.

DDDdomain-driven designmicroservices
0 likes · 6 min read
Can DDD’s Six‑Step Method Rescue a Broken Microservices Architecture?
Internet Backend Architecture Stack
Internet Backend Architecture Stack
Aug 6, 2026 · Backend Development

Microservice Dependency Governance: Eliminate Circular Dependencies & Rebuild Boundaries

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
Microservice Dependency Governance: Eliminate Circular Dependencies & Rebuild Boundaries
Internet Backend Architecture Stack
Internet Backend Architecture Stack
Aug 5, 2026 · Backend Development

Domain Event Reliability & Eventual Consistency: Production-Ready DDD Event-Driven Patterns

This article details a production-ready event-driven architecture for DDD microservices, covering the complete domain event flow, local event table for message loss prevention, three idempotency patterns for duplicate consumption, ordering solutions, five common pitfalls, and a five-layer eventual consistency architecture.

Distributed SystemsIdempotencyLocal Event Table
0 likes · 12 min read
Domain Event Reliability & Eventual Consistency: Production-Ready DDD Event-Driven Patterns
Internet Backend Architecture Stack
Internet Backend Architecture Stack
Aug 4, 2026 · Backend Development

From Event Storming to Microservices: A Practical Guide to Bounded Context Splitting

This article provides a step-by-step methodology for splitting bounded contexts after event storming, covering four golden rules (transaction consistency, change frequency, semantic uniqueness, team boundaries), an e-commerce case study, communication patterns, common pitfalls, and a mapping formula from contexts to microservices.

Anti-Corruption LayerDDD ModelingEvent Storming
0 likes · 15 min read
From Event Storming to Microservices: A Practical Guide to Bounded Context Splitting
Internet Backend Architecture Stack
Internet Backend Architecture Stack
Aug 3, 2026 · Backend Development

Event Storming Tutorial: 5 Steps to Define Microservice Boundaries

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
Event Storming Tutorial: 5 Steps to Define Microservice Boundaries
Yunqi AI+
Yunqi AI+
Aug 1, 2026 · Artificial Intelligence

From DDD to Ontology: Turning Domain Knowledge into AI‑Ready Semantic Contracts

The article explains how to evolve a DDD‑based domain model into a cross‑system ontology that provides AI agents with unified facts, computable logic, and executable actions, using a six‑step process illustrated by a customer‑health‑score case and detailed governance practices.

AI AgentSemantic Servicedata governance
0 likes · 27 min read
From DDD to Ontology: Turning Domain Knowledge into AI‑Ready Semantic Contracts
Code Archaeology
Code Archaeology
Jul 30, 2026 · Fundamentals

Service-Based Architecture: A Pragmatic Middle Ground Between Monoliths and Microservices

This article explores service-based architecture as a practical distributed architecture style that offers independent deployment benefits without the complexity of microservices, covering its topology, domain services, API gateway, data topology, risks, characteristic scores, suitable scenarios, and team topology alignment.

ACID transactionsdistributed architecturedomain-driven design
0 likes · 12 min read
Service-Based Architecture: A Pragmatic Middle Ground Between Monoliths and Microservices
The Dominant Programmer
The Dominant Programmer
Jul 21, 2026 · Backend Development

Practical Guide to Applying Domain‑Driven Design in Spring Boot Microservices

This guide explains Domain‑Driven Design (DDD) and shows how to structure Spring Boot microservices by organizing code around business domains, detailing strategic and tactical concepts, package layouts, layer responsibilities, cross‑domain communication, comparisons with traditional layering, evolution steps, and common FAQs.

Backend ArchitectureDDDJava
0 likes · 19 min read
Practical Guide to Applying Domain‑Driven Design in Spring Boot Microservices
webdream
webdream
Jul 18, 2026 · Backend Development

Java Architecture Overview: 7 Key Patterns from Layered to DDD

The article explains why solid architecture matters for Java projects, outlines seven mainstream architectural patterns—including layered, DDD, hexagonal, clean, CQRS, event‑driven, and microkernel—and provides a decision guide to help teams choose the most suitable approach based on complexity, experience, performance, and evolution needs.

CQRSJavaLayered Architecture
0 likes · 11 min read
Java Architecture Overview: 7 Key Patterns from Layered to DDD
Internet Backend Architecture Stack
Internet Backend Architecture Stack
Jul 17, 2026 · Backend Development

Microservice Splitting Done Right: DDD Strategic & Tactical Patterns from Top Tech

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
Microservice Splitting Done Right: DDD Strategic & Tactical Patterns from Top Tech
Code Archaeology
Code Archaeology
Jul 15, 2026 · Fundamentals

Modular Monolith Architecture: Structure, Communication & Team Topology Explained

This article explores modular monolith architecture, comparing monolithic vs modular structures, peer-to-peer vs mediator communication patterns, characteristic ratings (cost, simplicity, modularity, deployability, maintainability, elasticity, fault tolerance), suitable and unsuitable scenarios, and aligned team topologies based on Fundamentals of Software Architecture.

domain-driven designmediator patternmodular monolith
0 likes · 7 min read
Modular Monolith Architecture: Structure, Communication & Team Topology Explained
Yumin Fish Harvest
Yumin Fish Harvest
Jul 14, 2026 · Backend Development

Mastering CQRS: When to Separate Read and Write in DDD

This article explains how CQRS splits write operations that enforce business rules using domain models from read operations optimized for page performance, illustrates common pitfalls of mixing the two, and provides concrete Java code, SQL examples, migration steps, validation checklists, and best‑practice guidelines for implementing lightweight CQRS in a DDD‑based backend.

Backend ArchitectureCQRSCommand Query Separation
0 likes · 26 min read
Mastering CQRS: When to Separate Read and Write in DDD
Yumin Fish Harvest
Yumin Fish Harvest
Jul 10, 2026 · Backend Development

When One Aggregate Isn’t Enough: Using Domain Services and Domain Events

The article explains why cross‑aggregate business logic belongs in domain services, how domain events capture immutable business facts, and demonstrates practical Spring Boot implementations—including in‑process publishing, message‑queue integration, and the Outbox pattern—while highlighting pitfalls and verification techniques.

Domain EventDomain ServiceOutbox Pattern
0 likes · 10 min read
When One Aggregate Isn’t Enough: Using Domain Services and Domain Events
Yumin Fish Harvest
Yumin Fish Harvest
Jul 10, 2026 · Fundamentals

Distinguishing Entities vs Value Objects in DDD: Criteria & Code

Learn how to tell whether a domain concept is an Entity or a Value Object by asking if its identity matters or only its attributes, see concrete examples with Money, Address and Order, understand immutable design, proper equals/hashCode implementation, and validation through unit tests.

ImmutableJavaValue Object
0 likes · 13 min read
Distinguishing Entities vs Value Objects in DDD: Criteria & Code
Yumin Fish Harvest
Yumin Fish Harvest
Jul 10, 2026 · Fundamentals

Prioritizing DDD Modeling: Focus on Domains, Subdomains, and Core Domains

This chapter explains how to strategically allocate modeling effort in a DDD project by distinguishing domains, subdomains, core, supporting, and generic subdomains, using the “Preferred Store” case to illustrate which areas merit detailed modeling and which can remain simple, ultimately guiding resource focus and decision‑making.

Core DomainStrategic Modelingdomain-driven design
0 likes · 8 min read
Prioritizing DDD Modeling: Focus on Domains, Subdomains, and Core Domains
Yumin Fish Harvest
Yumin Fish Harvest
Jul 10, 2026 · Backend Development

Why Traditional Service Layers Fail and How DDD Restores Order

The article shows how a typical three‑layer OrderService accumulates scattered business rules, mixes technical details with domain logic, lacks clear boundaries, and diverges from business language, then explains how Domain‑Driven Design reorganizes code around aggregates and bounded contexts to solve these problems while outlining when DDD is unnecessary.

DDDJavaService Layer
0 likes · 11 min read
Why Traditional Service Layers Fail and How DDD Restores Order
Infinite Tech Management
Infinite Tech Management
Jul 8, 2026 · Backend Development

Why “UserService” Is a Bad Name: Lessons from a 12,000‑Line Service

The article recounts a 12,000‑line UserService.java file, explains how the overly generic name masks multiple responsibilities, violates the single‑responsibility principle, and creates a distributed monolith, then shows how domain‑driven naming and bounded‑context splitting can restore clear architecture.

Single Responsibility Principledomain-driven designmicroservices
0 likes · 8 min read
Why “UserService” Is a Bad Name: Lessons from a 12,000‑Line Service
Tinker Programmer
Tinker Programmer
Jul 3, 2026 · Backend Development

How Aggregate Roots Guard Business Invariants – The Final Defense Line

The article examines a payroll bug caused by exposing internal collections, then explains three immutable‑focused rules for aggregate roots—expose only through the root, keep each transaction to a single aggregate, and reference other aggregates by ID only—showing how proper design prevents consistency errors, performance loss, and concurrency conflicts in Spring Boot applications.

@TransactionalAggregate RootConsistency
0 likes · 17 min read
How Aggregate Roots Guard Business Invariants – The Final Defense Line
Architectural Methodology
Architectural Methodology
Jun 30, 2026 · Backend Development

From MVC Three‑Layer to DDD Four‑Layer: How Layered Architecture Evolves

Facing a large version release that made the existing MVC three‑layer system hard to maintain, the author outlines the shortcomings of thin entity models, scattered service logic, and code bloat, then presents a DDD‑based four‑layer architecture with domain‑driven design, DIP, and CQRS to improve cohesion, reduce complexity, and support long‑term evolution.

DDDLayered ArchitectureMVC
0 likes · 11 min read
From MVC Three‑Layer to DDD Four‑Layer: How Layered Architecture Evolves
Tinker Programmer
Tinker Programmer
Jun 29, 2026 · Backend Development

Why Bounded Contexts Are the Real Basis for Splitting Microservices

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.

Backend ArchitectureBounded Contextdomain-driven design
0 likes · 13 min read
Why Bounded Contexts Are the Real Basis for Splitting Microservices
Long Ge's Treasure Box
Long Ge's Treasure Box
Jun 29, 2026 · Fundamentals

Mastering Architecture Design Principles: Layered, Cohesive, and DDD Approaches

This article explains core architecture design principles—including layered, hexagonal, and COLA structures—covers cohesion and coupling types with evaluation criteria, presents practical strategies to reduce coupling, and details domain‑driven design concepts such as bounded contexts, aggregates, and repository patterns, all illustrated with concrete code examples and decision records.

CohesionLayered Architecturearchitecture
0 likes · 14 min read
Mastering Architecture Design Principles: Layered, Cohesive, and DDD Approaches
Tinker Programmer
Tinker Programmer
Jun 28, 2026 · Backend Development

Why Ubiquitous Language Belongs in Code, Not Just Meetings

The article shows how mismatched business and code vocabularies cause confusion, then guides readers through building a shared glossary, renaming domain objects and types in Java, and enforcing the conventions with a code‑review checklist to keep the ubiquitous language alive in the codebase.

GlossaryJavacode review
0 likes · 11 min read
Why Ubiquitous Language Belongs in Code, Not Just Meetings
Tinker Programmer
Tinker Programmer
Jun 27, 2026 · Backend Development

What Real Problem Does DDD Solve? Cutting Through the Confusing Concepts

The article explains why traditional three‑layer architectures let business logic bloat inside services, demonstrates the pitfalls of anemic domain models with a 7,000‑line SalaryService example, and shows how DDD’s rich domain model restores rule ownership and maintainability.

Anemic Domain ModelJavaService Layer
0 likes · 10 min read
What Real Problem Does DDD Solve? Cutting Through the Confusing Concepts
Architecture Breakthrough
Architecture Breakthrough
Jun 25, 2026 · R&D Management

How to Design System Architecture Diagrams with DDD in the AI Era

The article explains how architects can bridge high‑level platform diagrams and concrete implementation by using DDD‑based module functional diagrams that serve as prompts for AI code generation, avoiding low‑level detail while ensuring domain understanding guides development.

AI Prompt EngineeringArchitecture DiagramDDD
0 likes · 4 min read
How to Design System Architecture Diagrams with DDD in the AI Era
webdream
webdream
Jun 24, 2026 · Backend Development

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

The article analyzes whether endorsement (policy changes) and policy management should reside in a single microservice or be split into two, weighing data consistency, cohesion, operational simplicity, scaling, deployment independence, fault isolation, team size, and compliance, and provides a concrete decision framework and split strategy.

CQRSdomain-driven designevent-driven architecture
0 likes · 11 min read
Combine or Split Endorsement and Policy? Microservice for Life‑Insurance
Thought Artisan
Thought Artisan
Jun 23, 2026 · Fundamentals

First Principles Design: How Top Engineers Rethink System Architecture

This article compiles first-principles design philosophies from ten software engineering leaders, including LLVM creator Chris Lattner and Perfetto expert Lalit Maganti, showing how to break problems to fundamental constraints rather than copying existing solutions.

Chris LattnerLLVMdomain-driven design
0 likes · 15 min read
First Principles Design: How Top Engineers Rethink System Architecture
Digital Deification
Digital Deification
Jun 10, 2026 · R&D Management

Four-Level Object Chain: Business Architecture → Ontology → Knowledge Graph → Digitalization

The article argues that business architecture, ontology, knowledge graphs, and business object digitalization form a sequential four-level chain—governance boundaries, semantic definitions, instance relationships, and operational implementation—that must be built in order to achieve consistent enterprise-wide object identity and avoid failed digitalization efforts.

business architecturebusiness object digitalizationdigital transformation
0 likes · 13 min read
Four-Level Object Chain: Business Architecture → Ontology → Knowledge Graph → Digitalization
ZhiKe AI
ZhiKe AI
Jun 8, 2026 · Backend Development

Microservices Unpacked: Why Independent Deployment Trumps Just Splitting Services

The article clarifies that microservices are defined by business‑capability‑aligned, independently deployable services—not merely smaller services—detailing five core mechanisms, distributed‑system constraints, SOA comparison, and five common misconceptions.

CAP theoremDistributed SystemsIndependent Deployment
0 likes · 14 min read
Microservices Unpacked: Why Independent Deployment Trumps Just Splitting Services
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
ZhiKe AI
ZhiKe AI
Jun 5, 2026 · Fundamentals

Understanding Onion Architecture: Beyond the Concentric Circles

The article explains that Onion Architecture’s essence lies in inward‑facing dependencies rather than the visual onion shape, details its six‑layer structure, clarifies common misconceptions, and compares it with Clean and Hexagonal architectures to show how it improves testability and replaceability.

Onion Architectureclean architecturedependency inversion
0 likes · 12 min read
Understanding Onion Architecture: Beyond the Concentric Circles
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.

CQRSarchitecturedomain-driven design
0 likes · 7 min read
Two Common CQRS Design Approaches and How to Choose the Right One
ZhiKe AI
ZhiKe AI
Jun 2, 2026 · Backend Development

Why DDD Still Fails to Deliver Business‑Friendly Code When Treated as a Mere Architecture Pattern

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
Why DDD Still Fails to Deliver Business‑Friendly Code When Treated as a Mere Architecture Pattern
ZhiKe AI
ZhiKe AI
Jun 1, 2026 · Backend Development

Balancing Software Architecture Choices in Real Projects

The article explains that software architecture is fundamentally about trade‑offs, categorises major architecture families such as DDD, Clean/Hexagonal/Onion, Microservices vs SOA, CQRS/Event Sourcing, MVC, PACELC, BASE, FLP, Repository and 12‑Factor principles, and shows how each addresses specific constraints to help engineers pick the most suitable design for their context.

CAPDesign PatternsPACELC
0 likes · 12 min read
Balancing Software Architecture Choices in Real Projects
Xiaolin Talks Programming
Xiaolin Talks Programming
May 27, 2026 · Backend Development

DDD Implementation Guide: Bounded Contexts, Aggregates, Domain Events & Spring Boot Architecture

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
DDD Implementation Guide: Bounded Contexts, Aggregates, Domain Events & Spring Boot Architecture
ZhiKe AI
ZhiKe AI
May 14, 2026 · Fundamentals

Why DDD Is a Cognitive Alignment Tool, Not Just an Architecture

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
Why DDD Is a Cognitive Alignment Tool, Not Just an Architecture
samdeepthink
samdeepthink
May 12, 2026 · Backend Development

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

The author recounts three years of applying Domain‑Driven Design to a microservice ecosystem, sharing concrete pitfalls, code‑first modeling from database tables, and a structured 24‑article series that guides developers to refactor existing Spring Boot + MyBatis Plus projects without rewriting the framework.

Bounded ContextCQRSMyBatis Plus
0 likes · 8 min read
Three Years of DDD in Practice: Insights from the Opening Chapter
Mike Chen's Internet Architecture
Mike Chen's Internet Architecture
Apr 9, 2026 · Fundamentals

Mastering Domain-Driven Design: Core Concepts and Practical Guide

Domain-Driven Design (DDD) centers software architecture on business domains, breaking complex problems into clear subdomains, defining bounded contexts, ubiquitous language, and key building blocks such as entities, value objects, and aggregates, while guiding layered architecture and microservice decomposition for maintainable, collaborative systems.

DDDdomain-driven designmodeling
0 likes · 7 min read
Mastering Domain-Driven Design: Core Concepts and Practical Guide
IT Architects Alliance
IT Architects Alliance
Mar 30, 2026 · Industry Insights

How Domain‑Driven Design Turns Complex Business Logic into Clear Code

This article explains why domain models are needed, walks through DDD's strategic and tactical design concepts, demonstrates a full knowledge‑payment platform case with bounded contexts, aggregates, and ubiquitous language, and outlines practical guidelines and limitations for applying DDD in real projects.

AggregateStrategic Designdomain-driven design
0 likes · 10 min read
How Domain‑Driven Design Turns Complex Business Logic into Clear Code
java1234
java1234
Feb 7, 2026 · Backend Development

Why Service Layer Should Not Return a Result Object in Java

The article explains why returning a generic Result wrapper from a Java service layer breaks responsibility separation, harms reusability, complicates exception handling and testing, and obscures transaction boundaries, advocating for returning pure domain objects instead.

Design PrinciplesJavaResult Object
0 likes · 13 min read
Why Service Layer Should Not Return a Result Object in Java
Java Companion
Java Companion
Feb 7, 2026 · Backend Development

Why Should the Service Layer in Java Not Return a Result Object Directly?

The article explains that returning a Result wrapper from the Service layer mixes business logic with presentation concerns, leading to tighter coupling, reduced reusability, cumbersome error handling, harder testing, poorer DDD alignment, limited interface flexibility, and ambiguous transaction boundaries.

JavaResult WrapperSeparation of Concerns
0 likes · 11 min read
Why Should the Service Layer in Java Not Return a Result Object Directly?
dbaplus Community
dbaplus Community
Jan 13, 2026 · Backend Development

How AI‑Driven DDD Refactoring Cut Service Package Development from Days to Hours

This article presents a detailed case study of using AI to assist domain‑driven design (DDD) for refactoring Taobao's monolithic flash‑sale service‑package system, showing how automated context extraction, code skeleton generation, and AI‑augmented implementation reduced development effort from 5‑8 person‑days to a configurable solution while improving architecture decoupling, code quality, and extensibility.

AIarchitecturecode generation
0 likes · 15 min read
How AI‑Driven DDD Refactoring Cut Service Package Development from Days to Hours
Code Wrench
Code Wrench
Jan 8, 2026 · Backend Development

From Hexagonal Architecture to DDD: A Practical Evolution Path for Your System

This article explains how hexagonal architecture serves as a solid foundation for gradually introducing domain‑driven design, outlines the stages of evolution, highlights common pitfalls, and provides concrete code examples to help teams decide when to move beyond hexagonal alone.

DDDclean architecturedomain-driven design
0 likes · 8 min read
From Hexagonal Architecture to DDD: A Practical Evolution Path for Your System
Architect
Architect
Jan 2, 2026 · Backend Development

How DDD Transforms Spring Cloud Alibaba Microservices: A Practical Guide

This article explains the fundamentals of Domain‑Driven Design, its core principles and two design phases, then shows how to apply DDD within a Spring Cloud Alibaba e‑commerce microservice system, providing a detailed layered architecture, file‑structure example, and recommendations for implementation.

DDDJavaSpring Cloud Alibaba
0 likes · 11 min read
How DDD Transforms Spring Cloud Alibaba Microservices: A Practical Guide
DaTaobao Tech
DaTaobao Tech
Dec 31, 2025 · Backend Development

How AI Transformed a Taobao Service‑Package System with Domain‑Driven Design

This article examines how a rapidly growing Taobao flash‑sale service‑package system suffered from high development costs, duplicated code, and tight coupling, and shows how AI‑assisted domain‑driven design was applied to refactor the architecture, automate code generation, and dramatically improve efficiency, maintainability, and extensibility.

AIBackend RefactoringJava
0 likes · 13 min read
How AI Transformed a Taobao Service‑Package System with Domain‑Driven Design
ITPUB
ITPUB
Dec 28, 2025 · Backend Development

AI-Driven DDD Refactoring: From Monolithic Service Packages to Modular Architecture

Using AI to assist domain-driven design, this case study details how a monolithic Taobao service-package system was analyzed, restructured, and refactored, reducing development effort from 5-8 person-days per package to configuration-based implementation while eliminating duplicated code and improving modularity, testability, and scalability.

AIdomain-driven designrefactoring
0 likes · 16 min read
AI-Driven DDD Refactoring: From Monolithic Service Packages to Modular Architecture
Architect's Journey
Architect's Journey
Dec 8, 2025 · Backend Development

COLA‑DDD Layered Architecture: A Powerful Tool for Decoupling and Refactoring

The article explains how the COLA‑DDD layered architecture merges Clean Object‑Oriented and Layered Architecture with Domain‑Driven Design to eliminate large‑muddy code, improve iteration speed, enhance scalability, and provide clear layer boundaries, CQRS, event‑driven processing, and low‑risk technical evolution.

COLADDDDecoupling
0 likes · 11 min read
COLA‑DDD Layered Architecture: A Powerful Tool for Decoupling and Refactoring
Architect's Journey
Architect's Journey
Dec 5, 2025 · Backend Development

Capacity‑Driven Microservice Architecture: Solving High‑Concurrency Challenges

The article explains how a capacity‑driven microservice architecture uses performance metrics like QPS, TPS, and latency as the primary split criterion, detailing design principles, module responsibilities, and practical benefits that enable systems to handle traffic spikes without service collapse.

capacity‑driven architecturedomain-driven designhigh-concurrency
0 likes · 10 min read
Capacity‑Driven Microservice Architecture: Solving High‑Concurrency Challenges
php Courses
php Courses
Dec 4, 2025 · Backend Development

From Procedural PHP to Modern Practices: Transform Your Development Mindset

This article examines how early PHP developers often wrote tangled, procedural code that mixes business logic with presentation, and outlines concrete steps—adopting OOP, design patterns, domain‑driven design, test‑driven development, and modern tooling—to shift toward a cleaner, more maintainable backend development approach.

Design PatternsOOPPHP
0 likes · 7 min read
From Procedural PHP to Modern Practices: Transform Your Development Mindset
Rare Earth Juejin Tech Community
Rare Earth Juejin Tech Community
Nov 9, 2025 · Backend Development

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

The article shares the author's practical frustrations with Domain‑Driven Design—covering confusing CQRS classifications, ambiguous aggregate‑root boundaries, performance conflicts, and the high time cost—while offering concrete examples, code snippets, and a candid conclusion that DDD should be applied judiciously rather than dogmatically.

CQRSDDDdomain-driven design
0 likes · 25 min read
Why I Stopped Using DDD: Real‑World Pain Points and Lessons Learned
Su San Talks Tech
Su San Talks Tech
Nov 2, 2025 · Fundamentals

Unraveling Complex Systems: Key Architecture Principles and Design Strategies

This article explains what constitutes a complex system, defines software architecture, explores various architecture types, outlines key design factors, presents analysis methods like DDD, and reviews typical solutions such as microservices, cloud‑native, DevOps, and big‑data architectures for building robust, scalable systems.

Design Principlescomplex systemsdomain-driven design
0 likes · 16 min read
Unraveling Complex Systems: Key Architecture Principles and Design Strategies
Architect
Architect
Nov 1, 2025 · Fundamentals

What Makes a Complex System? Unveiling the Core Principles of Software Architecture

Complex systems are composed of many interacting components, and understanding their architecture—from business and application layers to technical, data, microservice, cloud‑native, and DevOps designs—requires grasping core principles, requirements, and design patterns that ensure reliability, scalability, and long‑term value.

Design Principlescomplex systemsdomain-driven design
0 likes · 17 min read
What Makes a Complex System? Unveiling the Core Principles of Software Architecture
Architect
Architect
Sep 18, 2025 · Fundamentals

Why Modeling Is the Hardest Puzzle in Software Architecture – A Deep Dive

This article explores the essential role of modeling in software engineering, outlines the three main types of modeling, examines why modeling remains a persistent challenge due to language ambiguity and real‑world complexity, and provides practical guidance on business and domain modeling for architects.

Software Modelingarchitecturebusiness analysis
0 likes · 16 min read
Why Modeling Is the Hardest Puzzle in Software Architecture – A Deep Dive
DaTaobao Tech
DaTaobao Tech
Sep 5, 2025 · Fundamentals

What the ‘Big Mud Ball’ Teaches About Modern Software Architecture

The article explores core software architecture challenges through eight resonant concepts—big mud ball, independent value, domain division, concept design, classification perspective, domain thickness, global versus local, and scaffolding—offering practical strategies to avoid code chaos, clarify responsibilities, and foster engineering excellence.

architecture modernizationdomain-driven designengineering excellence
0 likes · 14 min read
What the ‘Big Mud Ball’ Teaches About Modern Software Architecture
IT Architects Alliance
IT Architects Alliance
Aug 31, 2025 · Backend Development

7 Common Architecture Mistakes Chinese Developers Make and How to Fix Them

After analyzing thousands of Chinese projects, the article reveals seven pervasive architecture design pitfalls—overreliance on frameworks, chasing trends, neglecting domain modeling, ignoring evolution, overlooking non‑functional requirements, lacking team standards, and weak testing—offering practical guidance to adopt business‑driven, scalable, maintainable designs.

backend designdomain-driven designmicroservices
0 likes · 9 min read
7 Common Architecture Mistakes Chinese Developers Make and How to Fix Them
Zhuanzhuan Tech
Zhuanzhuan Tech
Aug 1, 2025 · Fundamentals

Unlock Faster, Clearer Software Design with Event Storming: A Practical Guide

This article explains how Event Storming—a collaborative, sticky‑note‑driven workshop—helps teams break down complex business processes into events, commands, aggregates and policies, dramatically speeding up requirements analysis, improving model quality, and turning the resulting model directly into code and living documentation.

Agile CollaborationEvent StormingSoftware Modeling
0 likes · 14 min read
Unlock Faster, Clearer Software Design with Event Storming: A Practical Guide
Tencent Cloud Developer
Tencent Cloud Developer
Jul 22, 2025 · Fundamentals

Why Good Software Architecture Is the Key to Solving Complex Business Problems

This article explores the essence of software architecture, tracing its definition, its role in solving division‑of‑labor challenges, and how a pragmatic, balanced design that treats architecture as software design itself can deliver sustainable value while navigating business complexity, team coordination, and evolving requirements.

Design Principlescomplexity managementdomain-driven design
0 likes · 47 min read
Why Good Software Architecture Is the Key to Solving Complex Business Problems
Code Ape Tech Column
Code Ape Tech Column
Jul 14, 2025 · Backend Development

Mastering Hexagonal Architecture in Spring Boot: 3 Implementation Strategies

This article explains the fundamentals of hexagonal (ports‑and‑adapters) architecture, presents three ways to implement it in Spring Boot—including a classic version, a DDD‑enhanced version, and a simplified variant—while analyzing their advantages, disadvantages, and suitable scenarios.

domain-driven designhexagonal-architecturesoftware architecture
0 likes · 35 min read
Mastering Hexagonal Architecture in Spring Boot: 3 Implementation Strategies
Code Ape Tech Column
Code Ape Tech Column
Jul 10, 2025 · Backend Development

Why DDD Is the Missing Piece in Your Microservices Architecture

This article explains how Domain‑Driven Design (DDD) complements microservice architecture by addressing functional partitioning gaps, guiding system decomposition, and improving scalability, while also highlighting common microservice pitfalls and practical steps for clear bounded‑context modeling.

backend developmentdomain-driven designmicroservices
0 likes · 9 min read
Why DDD Is the Missing Piece in Your Microservices Architecture
Rare Earth Juejin Tech Community
Rare Earth Juejin Tech Community
Jul 8, 2025 · Backend Development

Master DDD: Practical Guide to Domain‑Driven Design Architecture with Code

This article introduces the fundamentals of Domain‑Driven Design (DDD), explains key concepts such as rich domain models, entities, value objects, aggregates, repositories, adapters, and application orchestration, and demonstrates their implementation through comprehensive Java code examples and a complete project structure diagram.

DDDRepositoryarchitecture
0 likes · 15 min read
Master DDD: Practical Guide to Domain‑Driven Design Architecture with Code
ITFLY8 Architecture Home
ITFLY8 Architecture Home
Jun 6, 2025 · Backend Development

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

This article explains why overly fine‑grained service splitting hurts performance and debugging, shows best‑practice granularity aligned with team size, introduces evolutionary splitting based on model responsibilities, and walks through real‑world case studies, domain‑driven design concepts, architectural patterns such as hexagonal, CQRS, and event‑driven designs, and practical steps for building a robust service‑oriented system.

CQRSdomain-driven designevent-driven
0 likes · 6 min read
How to Split Services Effectively: Principles, Real Cases, and Domain Modeling
Baidu Geek Talk
Baidu Geek Talk
May 21, 2025 · Backend Development

Applying Domain‑Driven Design to Build Maintainable and Scalable Backend Architecture

This article explains how the increasing complexity of business logic in modern backend systems leads to tangled code, and demonstrates how strategic and tactical Domain‑Driven Design (DDD) concepts—such as bounded contexts, aggregates, entities, value objects, repositories, and application services—can decouple business and technology, improve maintainability, extensibility, and stability, and guide practical layered architecture implementation.

Backend ArchitectureClean CodeDDD
0 likes · 30 min read
Applying Domain‑Driven Design to Build Maintainable and Scalable Backend Architecture
DaTaobao Tech
DaTaobao Tech
May 14, 2025 · Backend Development

How a 2‑Year Journey Unified Java Backend Code Structure for Better Readability and Maintenance

This article shares a two‑and‑a‑half year effort to standardize code style and architecture across a large Java backend, detailing the origins, evolving patterns, a unified layered model, concrete implementation examples, measurable benefits, and future directions for continuous improvement.

Backend ArchitectureCode styleService Layer
0 likes · 16 min read
How a 2‑Year Journey Unified Java Backend Code Structure for Better Readability and Maintenance
Java Tech Enthusiast
Java Tech Enthusiast
Apr 20, 2025 · Backend Development

Understanding Domain-Driven Design (DDD) with Practical Examples

Domain‑Driven Design (DDD) aligns software structure with business concepts by embedding rules in rich domain models, using aggregates, domain services, and events, contrasting with traditional anemic layers, and is ideal for complex, evolving domains such as e‑commerce, finance, or ERP systems.

DDDDesign PatternsJava
0 likes · 9 min read
Understanding Domain-Driven Design (DDD) with Practical Examples
dbaplus Community
dbaplus Community
Apr 9, 2025 · Backend Development

How DDD and Hexagonal Architecture Revamp Huolala’s CRM System

This article explores how Domain‑Driven Design and hexagonal (clean) architecture were applied to Huolala’s user CRM, detailing the tactical design patterns, module breakdown, code examples, and the step‑by‑step migration that improved scalability, maintainability, and development efficiency.

DDDJavadomain-driven design
0 likes · 43 min read
How DDD and Hexagonal Architecture Revamp Huolala’s CRM System
Architecture Breakthrough
Architecture Breakthrough
Mar 31, 2025 · Fundamentals

Why Mastering Abstraction Is the Real Skill Behind Great Software Design

The article explains that while encapsulation, inheritance, and polymorphism are often highlighted, true software craftsmanship hinges on the ability to abstract—identifying essential features, discarding irrelevant details, and modeling problem domains through steps like analysis, concept extraction, and system design, supported by principles such as low coupling, high cohesion, sufficiency, and completeness.

CohesionDesign Principlesabstraction
0 likes · 10 min read
Why Mastering Abstraction Is the Real Skill Behind Great Software Design
Architecture Breakthrough
Architecture Breakthrough
Mar 4, 2025 · Product Management

How Business Knowledge Can Future‑Proof Your Development Career in the AI Age

The article explains why developers must combine deep business understanding with AI tools, outlines a three‑layer domain model (core, generic, supporting), debunks common misconceptions, and provides a step‑by‑step methodology for mastering banking business concepts to boost ROI and career resilience.

AI IntegrationProcess Improvementdomain-driven design
0 likes · 21 min read
How Business Knowledge Can Future‑Proof Your Development Career in the AI Age
37 Interactive Technology Team
37 Interactive Technology Team
Feb 19, 2025 · Fundamentals

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

The article explains how Domain‑Driven Design combined with microservice architecture can restructure a monolithic transaction system by defining bounded contexts, applying patterns such as layered architecture, CQRS and event‑driven communication, and refactoring domains to improve maintainability, scalability, and business clarity.

Bounded ContextCQRSdomain-driven design
0 likes · 9 min read
Domain-Driven Design (DDD) and Microservice Architecture: Concepts, Patterns, and Refactoring Strategies
Architect's Journey
Architect's Journey
Jan 22, 2025 · Backend Development

Deep Dive into DDD Rich Model: Best Practices

The article explains the DDD rich (or active) model, its core characteristics, compares it with the anemic model, and shows how to apply it in a shared‑rental billing domain using Java, DDD layers, domain events, and a lightweight framework.

Backend ArchitectureDDDJava
0 likes · 10 min read
Deep Dive into DDD Rich Model: Best Practices
Rare Earth Juejin Tech Community
Rare Earth Juejin Tech Community
Jan 15, 2025 · Backend Development

Principles and Guidelines for Splitting Microservices

This article discusses why and how to split monolithic applications into microservices, outlining common pitfalls of over‑splitting and presenting practical principles such as team and domain isolation, the three‑person rule, read/write separation, dependency management, and service count guidelines.

Backend Architecturedomain-driven designmicroservices
0 likes · 15 min read
Principles and Guidelines for Splitting Microservices
Eric Tech Circle
Eric Tech Circle
Jan 14, 2025 · Backend Development

DDD vs MVC: Practical Trade‑offs, Pitfalls, and When to Keep It Simple

This article compares Domain‑Driven Design and MVC, outlines the architectural changes such as dependency inversion and layer separation, examines common drawbacks in real projects, and offers concrete guidance on when to adopt DDD, blend it with MVC, or stick to a lightweight CRUD‑centric approach.

Backend ArchitectureBest PracticesDDD
0 likes · 9 min read
DDD vs MVC: Practical Trade‑offs, Pitfalls, and When to Keep It Simple
Huolala Tech
Huolala Tech
Jan 10, 2025 · Backend Development

How DDD and Hexagonal Architecture Transform a CRM System – A Practical Walkthrough

This article explores the practical application of Domain‑Driven Design and hexagonal architecture in a real‑world CRM system, detailing strategic and tactical design, module division, code examples, and a step‑by‑step migration from a traditional layered architecture to a more flexible, maintainable backend solution.

DDDbackend developmentdomain-driven design
0 likes · 49 min read
How DDD and Hexagonal Architecture Transform a CRM System – A Practical Walkthrough
DaTaobao Tech
DaTaobao Tech
Jan 8, 2025 · Fundamentals

Domain‑Driven and Process‑Driven Code Design Patterns

The article proposes a domain‑model‑driven code paradigm—defining clear business models, core domain objects, and infrastructure abstractions like repositories, facades, and factories—while contrasting it with process‑driven designs using ability nodes and chains, arguing that these patterns cut repetitive effort and boost maintainability.

Ability PatternJavaProcess-Driven
0 likes · 16 min read
Domain‑Driven and Process‑Driven Code Design Patterns
Alibaba Cloud Developer
Alibaba Cloud Developer
Jan 3, 2025 · Fundamentals

Master System Design: From Mindset to Architecture – A Complete Knowledge Framework

This comprehensive guide walks readers through the entire system design process, covering problem definition, key concepts, system analysis, modeling techniques, architectural thinking, design tools, requirements gathering, domain‑driven and use‑case modeling, design principles, patterns, and practical architecture delivery.

domain-driven designmodelingrequirements analysis
0 likes · 43 min read
Master System Design: From Mindset to Architecture – A Complete Knowledge Framework
Java Tech Enthusiast
Java Tech Enthusiast
Dec 31, 2024 · Backend Development

Discussion on Adopting Domain-Driven Design (DDD) in a Growing Business

The team concluded that adopting Domain‑Driven Design can be valuable, but only when a company can afford the upfront investment, has a shared language and cross‑department collaboration, possesses strong OOP expertise, and maintains a culture supportive of the required organizational change.

DDDbackend developmentdomain-driven design
0 likes · 4 min read
Discussion on Adopting Domain-Driven Design (DDD) in a Growing Business
Mike Chen's Internet Architecture
Mike Chen's Internet Architecture
Dec 30, 2024 · Backend Development

Comprehensive Introduction to Domain-Driven Design (DDD)

This article provides a comprehensive overview of Domain-Driven Design (DDD), explaining its core principles, layered architecture, domain model components such as entities, value objects, aggregates, and bounded contexts, and includes Java code examples to illustrate implementation.

DDDDesign PatternsJava
0 likes · 6 min read
Comprehensive Introduction to Domain-Driven Design (DDD)