BestHub
Sign in
Tagged articles

backend-architecture

957 articles · Page 2 of 10
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.

DDDDomain-Driven DesignMicroservices
0 likes · 30 min read
Applying Domain‑Driven Design to Build Maintainable and Scalable Backend Architecture
Code Ape Tech Column
Code Ape Tech Column
May 19, 2025 · Backend Development

Mastering CQRS in Spring Microservices: From Basics to Event Sourcing

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

AxonCQRSEvent Sourcing
0 likes · 13 min read
Mastering CQRS in Spring Microservices: From Basics to Event Sourcing
Architect
Architect
May 16, 2025 · Industry Insights

How to Master High‑Concurrency Flash‑Sale Systems with Redis, MQ, and Inventory Hint

This article analyzes the challenges of e‑commerce flash‑sale spikes and presents four proven architectural patterns—pressure distribution, Redis + MQ, Inventory Hint, and their combined use—detailing their principles, Lua scripts, transaction messaging, and practical trade‑offs for building resilient, high‑throughput systems.

Flash SaleHigh concurrencyInventory Hint
0 likes · 15 min read
How to Master High‑Concurrency Flash‑Sale Systems with Redis, MQ, and Inventory Hint
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.

Code styleDomain-Driven Designbackend-architecture
0 likes · 16 min read
How a 2‑Year Journey Unified Java Backend Code Structure for Better Readability and Maintenance
Airbnb Technology Team
Airbnb Technology Team
May 13, 2025 · Backend Development

How Airbnb Scaled Its Postcard Generation System for Group Travel

Airbnb's media team engineered a scalable postcard generation pipeline that matches destinations, handles localized text layout, and delivers high‑performance images across iOS, Android, Web, and external messaging platforms using flexible templates, async processing, and pre‑generation strategies.

AirbnbLocalizationasynchronous processing
0 likes · 11 min read
How Airbnb Scaled Its Postcard Generation System for Group Travel
21CTO
21CTO
Apr 29, 2025 · Backend Development

Why Microservices Might Be the Right Architecture for Your Organization

Microservices are independently deployable services modeled around business domains, offering benefits like smaller deployments, reduced risk, faster release cycles, and clear data ownership, while also introducing challenges such as distributed system complexity, operational overhead, and data consistency, requiring careful design of communication and scaling strategies.

backend-architecturedeploymentdistributed systems
0 likes · 12 min read
Why Microservices Might Be the Right Architecture for Your Organization
Zhuanzhuan Tech
Zhuanzhuan Tech
Apr 28, 2025 · Backend Development

Design and Evolution of ZhiZhi Checkout Payment Routing System

This article presents an in‑depth analysis of the ZhiZhi checkout payment routing system, covering its historical evolution from basic configuration to rule‑engine and modular construction modes, detailing architecture, expression engine implementation, automatic anomaly detection, and future outlook for scalability and AI integration.

Expression EngineRule EngineSystem Design
0 likes · 28 min read
Design and Evolution of ZhiZhi Checkout Payment Routing System
Su San Talks Tech
Su San Talks Tech
Apr 27, 2025 · Backend Development

Mastering Microservices: Advantages, Challenges, and Essential Design Patterns

This article explains what microservices are, outlines their key advantages such as scalability and resilience, details the inherent challenges like complexity and security, and introduces essential design patterns—including Database‑Per‑Service, API Gateway, BFF, CQRS, Event Sourcing, Saga, Sidecar, Circuit Breaker, ACL, and Aggregator—to help architects build robust, maintainable systems.

Cloud NativeMicroservicesResilience
0 likes · 23 min read
Mastering Microservices: Advantages, Challenges, and Essential Design Patterns
Java Architect Essentials
Java Architect Essentials
Apr 25, 2025 · Backend Development

Precise Order‑Closing Delayed Tasks: Best Practices and Common Pitfalls

This article compares several ways to implement order‑closing delayed tasks—message‑queue delayed delivery, Redisson DelayQueue, Redis expiration listening, RabbitMQ dead‑letter queues, and time wheels—explaining their mechanisms, drawbacks, and recommending the most reliable solutions for production systems.

Delayed TasksMessage QueueRabbitMQ
0 likes · 7 min read
Precise Order‑Closing Delayed Tasks: Best Practices and Common Pitfalls
Selected Java Interview Questions
Selected Java Interview Questions
Apr 25, 2025 · Backend Development

Applying a Flow Engine and Plugin Extension Engine for Business Isolation and Extensibility in Backend Systems

The article explains why over‑designing with workflow orchestration is harmful, introduces a flow‑engine and plugin‑extension approach to achieve clean code isolation and easy business extension, and provides concrete Java examples from the open‑source MemberClub project.

Process Orchestrationbackend-architectureflow engine
0 likes · 10 min read
Applying a Flow Engine and Plugin Extension Engine for Business Isolation and Extensibility in Backend Systems
macrozheng
macrozheng
Apr 24, 2025 · Backend Development

How to Refactor a Task System with SpringBoot, RocketMQ, and QLExpress for Rapid Business Integration

This article explains how to redesign a task‑centered backend by standardizing message formats, making task completion conditions configurable, and leveraging Alibaba's QLExpress rule engine, dramatically reducing integration time from weeks to minutes while supporting micro‑service deployment with Docker and Kubernetes.

ConfigurationMicroservicesQLExpress
0 likes · 9 min read
How to Refactor a Task System with SpringBoot, RocketMQ, and QLExpress for Rapid Business Integration
Lobster Programming
Lobster Programming
Apr 17, 2025 · Backend Development

How Local Message Tables Solve Distributed Transaction Challenges

Using a local message table, developers can break down distributed transactions into local database operations and asynchronous MQ messages, ensuring eventual consistency, simplifying implementation, and handling retries, while balancing advantages like simplicity and compatibility against drawbacks such as added maintenance and potential queue dependencies.

Local Message TableMessage Queuebackend-architecture
0 likes · 5 min read
How Local Message Tables Solve Distributed Transaction Challenges
Tencent Cloud Developer
Tencent Cloud Developer
Apr 9, 2025 · Backend Development

Account Accounting Theory, Design, Performance Issues, and Core Architecture in Third‑Party Payment Platforms

The article explains payment‑platform accounting theory, describes asset and liability account structures, identifies performance bottlenecks from double‑entry and hotspot accounts, and outlines architectural evolution toward flexible (BASE) transactions with solutions such as pre‑debit‑then‑credit, balance‑simplification, merged posting, and multi‑account designs.

account designaccountingbackend-architecture
0 likes · 18 min read
Account Accounting Theory, Design, Performance Issues, and Core Architecture in Third‑Party Payment Platforms
IT Architects Alliance
IT Architects Alliance
Apr 2, 2025 · Backend Development

Designing High‑Concurrency Backend Architecture for E‑commerce Platforms

The article explains how to design a scalable, highly available backend system capable of handling millions of requests per second by defining key performance metrics, estimating traffic with the 2/8 rule, and applying architectural patterns such as load‑balanced clusters, vertical service splitting, distributed caching, and database master‑slave replication, illustrated with a Taobao case study.

High concurrencybackend-architecturedatabase replication
0 likes · 14 min read
Designing High‑Concurrency Backend Architecture for E‑commerce Platforms
Code Ape Tech Column
Code Ape Tech Column
Mar 25, 2025 · Backend Development

Improving MVC Three‑Tier Architecture with a Manager Layer

This article explains the classic MVC three‑tier architecture, identifies its drawbacks such as bloated service code and long‑running transactions, and proposes adding a Manager layer to separate generic business processing, improve code maintainability, and enhance performance in Java backend systems.

JavaMVCSpring
0 likes · 9 min read
Improving MVC Three‑Tier Architecture with a Manager Layer
Zhuanzhuan Tech
Zhuanzhuan Tech
Mar 13, 2025 · Backend Development

Design and Implementation of a Real-Time Product Tagging Platform for a Second‑Hand E‑Commerce System

This article presents a comprehensive technical case study of a three‑layer product‑tagging platform that addresses the challenges of fine‑grained operations, ensures real‑time tag updates, guarantees data consistency, and eliminates read bottlenecks through traffic separation, event‑driven processing, deduplication MQ, and multi‑level caching.

CachingData ConsistencyReal-time Processing
0 likes · 13 min read
Design and Implementation of a Real-Time Product Tagging Platform for a Second‑Hand E‑Commerce System
Java Captain
Java Captain
Mar 11, 2025 · Backend Development

Why Process Orchestration Is Essential for Backend Systems and How to Implement It with a Flow Engine

The article explains the drawbacks of over‑designing code with tangled if‑else branches, argues that process orchestration and plugin extensions provide clean isolation and extensibility for multiple business lines, and demonstrates a flow‑engine implementation with configuration, node definition, execution, and source code details.

Process Orchestrationbackend-architecturecode isolation
0 likes · 8 min read
Why Process Orchestration Is Essential for Backend Systems and How to Implement It with a Flow Engine
Java Architect Essentials
Java Architect Essentials
Mar 11, 2025 · Backend Development

Process Orchestration and Plugin Extension for Business Isolation and Extensibility in Backend Systems

The article explains why excessive if‑else logic harms maintainability, introduces flow‑engine and plugin‑extension techniques to isolate business code and enable flexible extensions, demonstrates their implementation in the open‑source MemberClub project with configuration, node definitions, execution flow, and source code examples.

JavaProcess Orchestrationbackend-architecture
0 likes · 8 min read
Process Orchestration and Plugin Extension for Business Isolation and Extensibility in Backend Systems
Architect's Guide
Architect's Guide
Mar 4, 2025 · Backend Development

Implementing Multi‑Tenant Architecture with Spring Boot and Spring Cloud

This article explains the concepts, advantages, design choices, database strategies, and step‑by‑step implementation of a multi‑tenant system using Java Spring Boot and Spring Cloud, including code samples for data sources, dynamic routing, and tenant management in cloud environments.

JavaMicroservicesMulti‑tenant
0 likes · 13 min read
Implementing Multi‑Tenant Architecture with Spring Boot and Spring Cloud
Java Web Project
Java Web Project
Feb 27, 2025 · Backend Development

Why Process Orchestration Is Critical for Scalable Backend Systems

The article explains how excessive if‑else logic in multi‑business middle‑platforms leads to maintenance nightmares and demonstrates, with concrete code and a real open‑source project, how a flow engine and plugin‑extension framework provide clean isolation, extensibility, and reliable execution of business processes.

JavaMicroservicesProcess Orchestration
0 likes · 8 min read
Why Process Orchestration Is Critical for Scalable Backend Systems
Architecture Digest
Architecture Digest
Feb 27, 2025 · Backend Development

Implementing a Flow Engine and Plugin Extension for Business Isolation and Extensibility in Backend Systems

The article explains why excessive conditional logic harms maintainability, introduces a flow‑engine and plugin‑extension architecture to isolate business code, demonstrates configuration and execution with Java examples from the open‑source MemberClub project, and lists the surrounding tech stack for practical learning.

JavaProcess isolationbackend-architecture
0 likes · 7 min read
Implementing a Flow Engine and Plugin Extension for Business Isolation and Extensibility in Backend Systems
Bilibili Tech
Bilibili Tech
Feb 25, 2025 · Artificial Intelligence

Design and Implementation of a Live Streaming Highlight System with AI Optimization

The paper details a live‑streaming highlight system that integrates heterogeneous data sources, uses a three‑stage pipeline with MySQL/Redis storage, applies sliding‑window interval optimization and AI‑driven title generation, scoring, and segment selection, managed by a shared state‑machine, and outlines future stability and observability improvements.

Highlight SystemRedisai-optimization
0 likes · 22 min read
Design and Implementation of a Live Streaming Highlight System with AI Optimization
Baidu Tech Salon
Baidu Tech Salon
Feb 20, 2025 · Backend Development

Avalanche Prevention Architecture in Baidu Netdisk: Practices and Solutions

Baidu Netdisk engineers protect its billion‑user service from cascading failures by deploying dynamic circuit‑breaker overload control, priority‑based traffic isolation, request‑validity filtering, socket‑level disconnect detection, and unified timestamp handling, a combination that dramatically reduces avalanche incidents and boosts overall availability.

avalanche preventionbackend-architecturecircuit breaker
0 likes · 17 min read
Avalanche Prevention Architecture in Baidu Netdisk: Practices and Solutions
Baidu Geek Talk
Baidu Geek Talk
Feb 17, 2025 · Operations

How Baidu Netdisk Prevents Service Avalanches: Dynamic Circuit Breaking & Queue Control

This article analyzes Baidu Netdisk's anti‑avalanche architecture, explaining how avalanche cascades occur in high‑concurrency services and detailing practical prevention, blocking, and mitigation techniques such as dynamic circuit breaking, traffic isolation, request‑validity checks, and socket‑level detection to maintain system reliability.

Dynamic ThrottlingOperationsavalanche mitigation
0 likes · 18 min read
How Baidu Netdisk Prevents Service Avalanches: Dynamic Circuit Breaking & Queue Control
21CTO
21CTO
Feb 9, 2025 · Databases

How Notion Scaled PostgreSQL with Database Sharding

Notion tackled severe PostgreSQL performance limits by sharding its Block table and related tables across 480 logical shards on 32 physical databases, using workspace IDs as shard keys, a dual‑write migration, and rigorous validation to achieve near‑zero downtime and faster response times.

PostgreSQLbackend-architecturedatabase sharding
0 likes · 7 min read
How Notion Scaled PostgreSQL with Database Sharding
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.

DDDDomain EventsDomain-Driven Design
0 likes · 10 min read
Deep Dive into DDD Rich Model: Best Practices
JD Cloud Developers
JD Cloud Developers
Jan 22, 2025 · Backend Development

Mastering High-Concurrency Inventory Deduction for Flash Sale Systems

This article explores practical strategies for handling the high‑concurrency inventory deduction problem in flash‑sale scenarios, covering lock‑based approaches, Redis caching, partitioned stock management, asynchronous updates, and distributed scaling techniques to prevent overselling and improve throughput.

High concurrencyRedisbackend-architecture
0 likes · 11 min read
Mastering High-Concurrency Inventory Deduction for Flash Sale Systems
IT Architects Alliance
IT Architects Alliance
Jan 21, 2025 · Backend Development

Microservice Architecture: Empowering Digital Transformation

The article explains how microservice architecture serves as a key technology enabling enterprises to achieve digital transformation by improving agility, efficiency, cost-effectiveness, and innovation across various industries, and provides practical guidance and real-world case studies for successful adoption.

backend-architecturesoftware engineering
0 likes · 24 min read
Microservice Architecture: Empowering Digital Transformation
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.

Domain-Driven DesignMicroservicesService Splitting
0 likes · 15 min read
Principles and Guidelines for Splitting Microservices
IT Architects Alliance
IT Architects Alliance
Jan 14, 2025 · Backend Development

Microservice Architecture: Common Problems and Solutions

Microservice architecture, once a buzzword, breaks monolithic applications into independent services, but introduces challenges such as service governance, communication, gateway management, fault tolerance, and tracing; the article outlines these issues and presents practical solutions like Consul/Eureka, REST/RPC, API gateways, Hystrix, and tracing tools.

API GatewayDistributed TracingService Governance
0 likes · 11 min read
Microservice Architecture: Common Problems and Solutions
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.

DDDDomain-Driven DesignMVC
0 likes · 9 min read
DDD vs MVC: Practical Trade‑offs, Pitfalls, and When to Keep It Simple
IT Architects Alliance
IT Architects Alliance
Jan 11, 2025 · Backend Development

Why Microservices Can’t Escape Distributed Transactions—and How to Solve Them

The article explains why distributed transactions are inevitable in microservice architectures, outlines the challenges of data consistency, fault handling, and performance, and presents practical solutions such as message‑queue eventual consistency, two‑phase commit, Saga patterns, and tooling like Spring Cloud, Atomikos, and Narayana.

2PCMessage QueueMicroservices
0 likes · 17 min read
Why Microservices Can’t Escape Distributed Transactions—and How to Solve Them
Top Architect
Top Architect
Dec 22, 2024 · Backend Development

Do Service Layers Need Interfaces? A Critical Discussion on Spring‑Based Projects

The article examines whether a Service layer in a Spring‑based backend should be defined by interfaces, debunks common arguments for using interfaces, proposes a top‑down coding workflow, explores project structures for single and multiple implementations, and concludes that interfaces are only worthwhile when multiple implementations are required, while also containing promotional material for unrelated services.

Dependency InjectionInterfacesbackend-architecture
0 likes · 11 min read
Do Service Layers Need Interfaces? A Critical Discussion on Spring‑Based Projects
Architecture Digest
Architecture Digest
Dec 22, 2024 · Backend Development

Technical Overview and History of China’s 12306 Railway Ticketing System

The article provides a detailed, informal yet informative overview of the evolution, architecture, and massive scale challenges of China’s 12306 railway ticketing platform, tracing its roots from early Unix‑based systems to modern distributed backend solutions handling billions of requests during peak travel periods.

ChinaHigh concurrencyRailway
0 likes · 9 min read
Technical Overview and History of China’s 12306 Railway Ticketing System
Su San Talks Tech
Su San Talks Tech
Dec 20, 2024 · Backend Development

7 Proven Strategies to Auto‑Cancel Unpaid Orders in High‑Traffic Systems

This article examines seven practical approaches—including Java DelayQueue, database polling, Redis queues, key‑expiration callbacks, RabbitMQ delayed messages, scheduled‑task frameworks, and event‑stream processing—to automatically cancel unpaid orders, comparing their scenarios, advantages, drawbacks, and implementation tips for scalable systems.

JavaOrder CancellationRabbitMQ
0 likes · 15 min read
7 Proven Strategies to Auto‑Cancel Unpaid Orders in High‑Traffic Systems
Huolala Tech
Huolala Tech
Dec 19, 2024 · Backend Development

How We Automated Driver Withdrawals: Architecture Evolution & Risk Controls

Facing rapid growth, Huolala transformed its driver withdrawal flow from a manual, siloed PHP system to a Java‑based platform with automated risk controls, monitoring dashboards, and weekend payouts, achieving full‑order security, higher stability, improved driver satisfaction, and significant cost reductions.

Risk Managementbackend-architecturefinancial technology
0 likes · 9 min read
How We Automated Driver Withdrawals: Architecture Evolution & Risk Controls
Architect
Architect
Dec 16, 2024 · Backend Development

How to Build a Scalable Feed Stream: Architecture, Models, and Best Practices

This article explains what a feed stream is, why it exists, how it evolved from RSS to modern social feeds, classifies different feed models, outlines the challenges of real‑time delivery, and provides a detailed backend architecture, data structures, storage design, pagination strategy, and core publish‑read workflows to help engineers build reliable, high‑performance feed systems.

Message QueueRead‑Write DiffusionRedis
0 likes · 23 min read
How to Build a Scalable Feed Stream: Architecture, Models, and Best Practices
Alibaba Cloud Developer
Alibaba Cloud Developer
Dec 16, 2024 · Backend Development

How Redis Stream Revolutionized Real‑Time Traffic Processing and Cut Costs by 90%

This article explains how the traffic team replaced a costly MQ system with Redis Stream, covering its concepts, design, implementation details such as load balancing and cross‑region deployment, monitoring metrics, performance benchmarks, practical lessons learned, and the scenarios where Redis Stream is most suitable.

Message QueueRedis Streambackend-architecture
0 likes · 12 min read
How Redis Stream Revolutionized Real‑Time Traffic Processing and Cut Costs by 90%
JavaEdge
JavaEdge
Dec 8, 2024 · Backend Development

Netflix’s Service‑Level Priority Load Shedding: Protecting User‑Initiated Requests

This article explains how Netflix extended its priority load‑shedding strategy from the API gateway to individual services, detailing the classification of user‑initiated versus pre‑fetch requests, the implementation of partitioned concurrency limiters, CPU‑ and I/O‑based shedding, test results, and real‑world impact on availability.

Netflixbackend-architectureconcurrency limits
0 likes · 18 min read
Netflix’s Service‑Level Priority Load Shedding: Protecting User‑Initiated Requests
High Availability Architecture
High Availability Architecture
Nov 22, 2024 · Backend Development

Designing a High‑Availability, Scalable Feed Stream System

This article introduces feed streams, explains their evolution from RSS to modern social feeds, classifies them by aggregation logic and display, discusses challenges such as real‑time performance and massive data, and presents a backend architecture with data models, pagination, write/read diffusion, and core publishing/reading workflows.

backend-architecturedata modelingfeed stream
0 likes · 21 min read
Designing a High‑Availability, Scalable Feed Stream System
Huolala Tech
Huolala Tech
Nov 22, 2024 · Backend Development

Building a Scalable Message Fusion Platform for Billions of User Notifications

This article details how a rapidly growing on‑demand logistics service designed and implemented a high‑performance, extensible message fusion platform that handles massive, diverse user messages through distributed processing, visual configuration, and self‑healing mechanisms, enabling real‑time, personalized communication at scale.

Distributed ProcessingMessage QueueScalable Systems
0 likes · 13 min read
Building a Scalable Message Fusion Platform for Billions of User Notifications
Zhuanzhuan Tech
Zhuanzhuan Tech
Nov 20, 2024 · Backend Development

Design and Implementation of a High‑Performance Message Notification System

This article presents a comprehensive design of a high‑performance, fault‑tolerant message notification system, covering service partitioning, system architecture, idempotent processing, dynamic error detection, thread‑pool management, retry mechanisms, and stability measures such as traffic‑spike handling, resource isolation, third‑party protection, monitoring, and active‑active deployment.

JavaMessage Notificationbackend-architecture
0 likes · 16 min read
Design and Implementation of a High‑Performance Message Notification System
JD Cloud Developers
JD Cloud Developers
Nov 20, 2024 · Backend Development

Designing Scalable Excel Import Pipelines: Four Architecture Patterns Compared

This article examines four architectural approaches for importing Excel data—synchronous, thread‑pooled with MQ, fully asynchronous with Redis locks, and an ideal high‑throughput variant—detailing their trade‑offs, performance impacts, and suitable business scenarios in modern backend systems.

Excel ImportRedis Lockasynchronous processing
0 likes · 10 min read
Designing Scalable Excel Import Pipelines: Four Architecture Patterns Compared
Architect
Architect
Nov 17, 2024 · Backend Development

How to Refactor a Multi‑Tenant Service to Reduce Coupling and Code Bloat

The article presents a real‑world case of a multi‑tenant system whose business logic was tightly coupled across tenants, leading to a massive service class, and demonstrates how applying Domain‑Driven Design, the Dependency Inversion Principle, and the Factory pattern can restructure the code into isolated tenant‑specific actions, improving maintainability and testability.

Code RefactoringDependency InversionDomain-Driven Design
0 likes · 6 min read
How to Refactor a Multi‑Tenant Service to Reduce Coupling and Code Bloat
JavaEdge
JavaEdge
Nov 16, 2024 · Backend Development

How Netflix Built a Low‑Latency Distributed Counter Service at Scale

This article explains Netflix's distributed counter abstraction built on their time‑series service, detailing use cases, API design, counter types, implementation methods, control‑plane configuration, performance results, and future work to achieve near‑real‑time, low‑latency counting at massive scale.

Netflixbackend-architecturecounter service
0 likes · 25 min read
How Netflix Built a Low‑Latency Distributed Counter Service at Scale
Architect
Architect
Nov 16, 2024 · Industry Insights

Ctrip’s Journey: Transforming the Account System from Monolith to Multi‑Region Platform

This article examines Ctrip’s evolution of its account system—from a monolithic service to a domain‑driven, middle‑platform architecture with multi‑region deployment—detailing the motivations, domain restructuring, read/write comparison process, configuration‑driven capabilities, and routing strategies that enable scalable, reliable user management.

Domain-Driven DesignMicroservicesaccount system
0 likes · 15 min read
Ctrip’s Journey: Transforming the Account System from Monolith to Multi‑Region Platform
Zhuanzhuan Tech
Zhuanzhuan Tech
Nov 14, 2024 · Backend Development

Design and Implementation of a Counting System for a B2B Marketplace

This article describes the background, requirements, and architectural design of a custom counting system for a B2B second‑hand trading platform, covering dimension definitions, internal vs external implementations, data flow, persistence strategies, code interfaces, and read‑query optimizations.

backend-architecturecounting systemdata aggregation
0 likes · 20 min read
Design and Implementation of a Counting System for a B2B Marketplace
Architect's Guide
Architect's Guide
Nov 13, 2024 · Backend Development

Designing a Modular Spring Boot Backend Project: Principles, Module Structure, and Maven Configuration

This article presents a comprehensive guide to building a Spring Boot backend system by outlining essential design principles, detailing a multi‑module architecture with clear responsibilities, and providing complete Maven POM configurations for each module to enable scalable and maintainable development.

JavaMicroservicesSpring Boot
0 likes · 14 min read
Designing a Modular Spring Boot Backend Project: Principles, Module Structure, and Maven Configuration
Architect
Architect
Nov 8, 2024 · Backend Development

How Ctrip Scaled Its Travel Product Log System to Billions of Records

This article traces the evolution of Ctrip’s travel product log platform—from a single‑table DB approach to a platform‑wide ES + HBase solution—detailing the challenges of massive data volume, the architectural decisions, RowKey design, write and query flows, and the subsequent extensions that enabled billion‑scale log storage and fast retrieval.

Big DataCtripES
0 likes · 17 min read
How Ctrip Scaled Its Travel Product Log System to Billions of Records
Huolala Tech
Huolala Tech
Nov 8, 2024 · Backend Development

How Huolala Built a Scalable Real‑Time Reconciliation Platform for Millions of Daily Transactions

Huolala’s real‑time reconciliation platform tackles massive daily transaction volumes by addressing distributed system consistency, high‑throughput data ingestion, dynamic cluster scaling, and security safeguards, enabling sub‑second settlement verification across hundreds of services.

Data ConsistencyDynamic ScalingSystem Security
0 likes · 10 min read
How Huolala Built a Scalable Real‑Time Reconciliation Platform for Millions of Daily Transactions
Architect
Architect
Oct 27, 2024 · Backend Development

How We Scaled a Lottery System to Over 1M Daily Users: Architecture & Performance Hacks

This article details the end‑to‑end architecture and step‑by‑step performance tuning of a high‑traffic lottery platform, covering server‑level rate limiting, application‑level throttling, semaphore usage, user‑behavior detection, caching strategies, database optimizations, and hardware upgrades that together enabled stable handling of millions of daily requests.

High concurrencyPerformance OptimizationSemaphore
0 likes · 15 min read
How We Scaled a Lottery System to Over 1M Daily Users: Architecture & Performance Hacks
Architecture Breakthrough
Architecture Breakthrough
Oct 22, 2024 · Backend Development

Can You Bypass the Mid‑Platform? When Direct Calls Across Service Layers Make Sense

The article analyzes a post‑mid‑platform reconstruction architecture, questioning whether channel or product layers can call backend modules directly, whether lower‑level services can push upward without breaking dependency inversion, and clarifies the subtle distinction between top‑down calls and bottom‑up pushes.

Dependency Inversionbackend-architecturecall vs push
0 likes · 5 min read
Can You Bypass the Mid‑Platform? When Direct Calls Across Service Layers Make Sense
Top Architect
Top Architect
Oct 19, 2024 · Backend Development

Microservice Architecture and Its Most Important Design Patterns

This article introduces microservice architecture, explains its advantages and disadvantages, and details ten essential design patterns—including Database per Service, Event Sourcing, CQRS, Saga, BFF, API Gateway, Strangler, Circuit Breaker, Externalized Configuration, and Consumer‑Driven Contract Testing—while providing guidance on when to apply each pattern and offering technology examples.

API Gatewaybackend-architecturecircuit breaker
0 likes · 34 min read
Microservice Architecture and Its Most Important Design Patterns
Senior Tony
Senior Tony
Oct 12, 2024 · Backend Development

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

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

API compositionCQRSCanal
0 likes · 8 min read
When Monolith Meets Microservices: API Composition vs CQRS for Complex Queries
Top Architect
Top Architect
Oct 8, 2024 · Backend Development

Design and Architecture of Payment Business Systems

This article analyzes the complexities of payment business logic, breaks down the workflow into modular components, illustrates sequence diagrams, discusses related domains such as product and coupon management, and summarizes key technical considerations like transaction handling, locking, and settlement.

Transaction Managementbackend-architecturee-commerce
0 likes · 10 min read
Design and Architecture of Payment Business Systems
Architect
Architect
Oct 1, 2024 · Backend Development

How We Engineered a Million‑User Lottery System to Survive Massive Spikes

This article details the end‑to‑end architecture, rate‑limiting strategies, caching layers, database optimizations, and hardware upgrades that enabled a lottery service to handle daily traffic exceeding one million users during peak promotional events.

CachingHigh concurrencyPerformance Optimization
0 likes · 15 min read
How We Engineered a Million‑User Lottery System to Survive Massive Spikes
Top Architect
Top Architect
Sep 27, 2024 · Backend Development

Why Adopt Microservices? Principles, Design Strategies, and Practical Implementation

This article explains why microservices have become a dominant architectural style, outlines the problems they solve, describes core characteristics, presents various splitting principles and methods, discusses the relationship with domain‑driven design, compares microservices to other architectures, and lists common technologies and best‑practice recommendations.

DDDService Splittingbackend-architecture
0 likes · 24 min read
Why Adopt Microservices? Principles, Design Strategies, and Practical Implementation
Top Architect
Top Architect
Sep 19, 2024 · Game Development

Why Game Companies' Servers Reluctant to Adopt Microservices

Although microservices are popular for many applications, this article explains why game servers often avoid them, citing real‑time latency requirements, stateful processing, high network overhead, and the difficulty of maintaining fast, low‑latency communication, while also interspersing promotional content for ChatGPT services.

backend-architecturegame serverreal-time performance
0 likes · 11 min read
Why Game Companies' Servers Reluctant to Adopt Microservices
Java High-Performance Architecture
Java High-Performance Architecture
Sep 9, 2024 · Backend Development

Designing a Scalable WebSocket Messaging Service with Reliable RabbitMQ Integration

This article outlines a comprehensive backend design that abstracts WebSocket into a reusable communication service, details project structure, business processes, reliability mechanisms for RabbitMQ, message classification, API design, and a unified message format to enable plug‑and‑play real‑time messaging across various Java applications.

JavaMessage QueueRabbitMQ
0 likes · 9 min read
Designing a Scalable WebSocket Messaging Service with Reliable RabbitMQ Integration
Tencent Cloud Developer
Tencent Cloud Developer
Sep 6, 2024 · Backend Development

Message Queue (MQ) Overview, Selection Criteria, and Comparison of Kafka, Pulsar, RocketMQ, RabbitMQ, and NSQ

The article surveys major message‑queue systems—Kafka, Pulsar, RocketMQ, RabbitMQ, and NSQ—detailing their architectures, key features, selection criteria such as ordering, scalability and latency, performance benchmarks, operational considerations, and typical use cases, and advises which platform best fits high‑throughput, reliability, low‑latency, or lightweight Go‑centric scenarios.

NSQPulsarRabbitMQ
0 likes · 47 min read
Message Queue (MQ) Overview, Selection Criteria, and Comparison of Kafka, Pulsar, RocketMQ, RabbitMQ, and NSQ
Code Ape Tech Column
Code Ape Tech Column
Sep 3, 2024 · Backend Development

Comprehensive Guide to API Gateway Design and Implementation

This article provides an in‑depth overview of API gateway concepts, design principles, key features such as routing, load balancing, security, resilience, and compares popular gateway solutions like OpenResty, Kong, Zuul, and Spring Cloud Gateway for microservice architectures.

API GatewayKongOpenResty
0 likes · 26 min read
Comprehensive Guide to API Gateway Design and Implementation
Top Architecture Tech Stack
Top Architecture Tech Stack
Aug 30, 2024 · Backend Development

Understanding Load Balancing and Gateway Architecture Through a Story

The article explains, using a startup scenario, how a single‑server setup leads to performance bottlenecks and single‑point failures, prompting the adoption of load balancing with Nginx and an additional gateway layer for authentication, security, and traffic control, while also containing promotional material for development tools.

NGINXTraffic Managementbackend-architecture
0 likes · 5 min read
Understanding Load Balancing and Gateway Architecture Through a Story
21CTO
21CTO
Aug 28, 2024 · Backend Development

Why Message Queues Are Essential for Scalable Backend Systems

This article explains how message queues decouple and buffer tasks such as payment processing, inventory updates, and notifications in high‑traffic online stores, improving reliability, scalability, and fault tolerance through asynchronous communication.

Message QueueRabbitMQasynchronous processing
0 likes · 6 min read
Why Message Queues Are Essential for Scalable Backend Systems
Senior Tony
Senior Tony
Aug 26, 2024 · Backend Development

Should Every Microservice Have Its Own Database? Pros, Cons, and Real‑World Lessons

This article examines the debate over sharing versus isolating databases in microservice architectures, presents arguments from both sides, shares a detailed incident from an online education platform, and outlines best‑practice recommendations for balancing availability, cost, and development efficiency.

Database isolationMicroservicesbackend-architecture
0 likes · 10 min read
Should Every Microservice Have Its Own Database? Pros, Cons, and Real‑World Lessons
Architect
Architect
Aug 14, 2024 · Backend Development

How to Build a Scalable Distributed Task Scheduling Platform

This article outlines the essential components and design considerations for creating a distributed task scheduling platform, covering triggers, scheduling strategies, executors, task chains, circuit breakers, exception handling, blocking control, service discovery, monitoring, and a management console.

Distributed SchedulingMonitoringbackend-architecture
0 likes · 9 min read
How to Build a Scalable Distributed Task Scheduling Platform
JD Tech Talk
JD Tech Talk
Aug 12, 2024 · Backend Development

Designing High‑Concurrency Systems: From Single‑Machine Optimizations to Distributed Architecture

This article explains how to build high‑concurrency systems by analyzing single‑machine hardware and code optimizations, clarifying multithreading versus asynchronous methods, and then scaling horizontally and vertically with caching, partitioning, and distributed inventory management to achieve stable, performant services for large‑scale e‑commerce workloads.

High concurrencyRedisasynchronous programming
0 likes · 18 min read
Designing High‑Concurrency Systems: From Single‑Machine Optimizations to Distributed Architecture
JavaEdge
JavaEdge
Aug 10, 2024 · Backend Development

Why an Event Center Beats Traditional MQ in Modern Backend Architecture

This article explains how an event‑center abstracts domain events, offers a clear architecture and powerful features, compares it with raw message‑queue solutions, and provides Java code examples to help backend engineers adopt a more maintainable, decoupled design.

DDDJavabackend-architecture
0 likes · 11 min read
Why an Event Center Beats Traditional MQ in Modern Backend Architecture
Top Architect
Top Architect
Aug 6, 2024 · Backend Development

Why and How to Adopt Microservices: Principles, Design Strategies, and Comparison with Other Architectures

The article explains why microservices have become a mainstream architectural style, outlines the problems of monolithic systems, presents core microservice characteristics, offers practical decomposition principles and patterns, compares microservices with monolith, distributed, serverless, SOA and service‑mesh architectures, and lists common technology stacks for implementation.

Domain-Driven Designbackend-architecturecloud-native
0 likes · 26 min read
Why and How to Adopt Microservices: Principles, Design Strategies, and Comparison with Other Architectures
Architect
Architect
Aug 5, 2024 · Backend Development

How to Build a Scalable WebSocket Communication Service with Reliable Messaging

This article outlines the design of an internal WebSocket communication service that abstracts real‑time messaging, reduces code coupling, supports various business scenarios, ensures reliable delivery with RabbitMQ, defines unified APIs and message formats, and demonstrates a DDD‑based project structure for easy integration.

API designDDDMessage Queue
0 likes · 10 min read
How to Build a Scalable WebSocket Communication Service with Reliable Messaging
Architect
Architect
Aug 1, 2024 · Backend Development

How a Structured Refactor Cut Game Service MQ Calls by Up to 80%

Facing a 600k/min rate‑limit alert on a game’s product‑update MQ, the team analyzed scattered consumers, designed a new Flyweight‑Strategy architecture with Spring AOP idempotency, executed a three‑phase migration, and achieved a 50‑80% reduction in downstream interface calls.

MQ RefactorMicroservicesPerformance Optimization
0 likes · 12 min read
How a Structured Refactor Cut Game Service MQ Calls by Up to 80%
Top Architect
Top Architect
Jul 31, 2024 · Backend Development

Why Adopt Microservices? Principles, Splitting Strategies, DDD Relationship, and Common Implementation Techniques

The article explains why microservices have become a mainstream architectural choice, outlines the shortcomings of monolithic systems, presents core design principles and various service‑splitting methods, discusses the synergy with Domain‑Driven Design, compares microservices with other architectures, and lists typical technologies used in practice.

Cloud NativeDDDService Splitting
0 likes · 23 min read
Why Adopt Microservices? Principles, Splitting Strategies, DDD Relationship, and Common Implementation Techniques
Code Ape Tech Column
Code Ape Tech Column
Jul 30, 2024 · Backend Development

Design and Implementation of a Unified WebSocket Communication Service for Backend Systems

This article describes the background, objectives, core design, reliability mechanisms, message classification, API design, and unified calling approach of a company‑wide WebSocket abstraction layer that replaces polling, supports asynchronous communication, and ensures reliable message delivery using RabbitMQ and confirm mechanisms.

Asynchronous CommunicationMessage QueueRabbitMQ
0 likes · 10 min read
Design and Implementation of a Unified WebSocket Communication Service for Backend Systems
Eric Tech Circle
Eric Tech Circle
Jul 29, 2024 · Backend Development

How to Keep Order Data Consistent Across Multiple External Systems

This article analyzes common data‑inconsistency problems in order‑placement workflows that involve many external services and presents a lightweight final‑consistency architecture with practical design guidelines, retry strategies, and compensation mechanisms to ensure reliable backend processing.

Data Consistencybackend-architecturedistributed transaction
0 likes · 6 min read
How to Keep Order Data Consistent Across Multiple External Systems
Architect
Architect
Jul 28, 2024 · Backend Development

Why Microservices? Benefits, Principles, and Practical Implementation Guide

This article provides a comprehensive analysis of microservices, covering why they are adopted, the drawbacks of monolithic architectures, core characteristics, splitting principles and strategies, the relationship with Domain‑Driven Design, comparisons with other architectural styles, and a detailed overview of the common technical stack used to build and operate microservice systems.

Cloud NativeDDDMicroservices
0 likes · 22 min read
Why Microservices? Benefits, Principles, and Practical Implementation Guide
DevOps
DevOps
Jul 23, 2024 · Backend Development

High Concurrency Solutions: CDN, Read‑Write Separation, NoSQL, and Caching Strategies

This article explains the concept of high concurrency, its key metrics, and presents four practical backend solutions—static/dynamic separation with CDN, read‑write separation using NoSQL and CQRS, various caching techniques, and lightweight read‑optimisation—to improve performance and scalability of distributed systems.

CDNHigh concurrencyNoSQL
0 likes · 23 min read
High Concurrency Solutions: CDN, Read‑Write Separation, NoSQL, and Caching Strategies
Architect
Architect
Jul 18, 2024 · Backend Development

Design and Implementation of a Channel Reconciliation System for ZuanZuan Payments

This article details the architecture, design principles, data preparation methods, verification processes, and error‑handling strategies of ZuanZuan's payment reconciliation system, highlighting how large‑scale data, binlog ingestion, Hive archiving, and MQ‑based workflows ensure accurate and secure financial settlements.

HiveMQReconciliation
0 likes · 11 min read
Design and Implementation of a Channel Reconciliation System for ZuanZuan Payments
Mike Chen's Internet Architecture
Mike Chen's Internet Architecture
Jul 11, 2024 · Backend Development

Mastering Distributed Architecture: From Microservices to Service Mesh

This article explains the fundamentals of distributed architecture, covering its key characteristics, microservice principles, Spring Cloud implementations, Service Mesh concepts, and essential components like distributed storage, caching, and transaction management for building scalable, resilient backend systems.

MicroservicesService Meshbackend-architecture
0 likes · 13 min read
Mastering Distributed Architecture: From Microservices to Service Mesh
Mike Chen's Internet Architecture
Mike Chen's Internet Architecture
Jul 4, 2024 · Backend Development

Mastering Distributed RPC: Principles, Workflows, and Top Frameworks Explained

This article explains the fundamentals of distributed RPC, outlines its end‑to‑end communication workflow, and compares major frameworks such as gRPC, Apache Thrift, Dubbo, Spring Cloud Netflix, ZeroMQ, Apache Avro, and gRPC‑Web, helping developers choose the right solution for their microservice architecture.

DubboMicroservicesbackend-architecture
0 likes · 6 min read
Mastering Distributed RPC: Principles, Workflows, and Top Frameworks Explained
Top Architect
Top Architect
Jul 4, 2024 · Backend Development

Understanding Service Gateways: Architecture, Benefits, and Technical Choices

This article explains what a service gateway is, why it is needed in micro‑service architectures, outlines its core functions such as routing and filtering, discusses deployment considerations, and presents a practical technology stack including Spring Boot, Zuul, Consul, JWT, Prometheus, and ELK.

FiltersRoutingZuul
0 likes · 9 min read
Understanding Service Gateways: Architecture, Benefits, and Technical Choices
IT Architects Alliance
IT Architects Alliance
Jul 2, 2024 · Backend Development

Do You Really Need Interfaces for Service and DAO Layers in Spring?

This article examines whether defining separate interfaces for Service and DAO layers is necessary in Spring projects, debunks common justifications, proposes a bottom‑up development workflow, and outlines project structures for single and multiple implementations, highlighting both benefits and drawbacks.

Dependency InjectionSpringbackend-architecture
0 likes · 8 min read
Do You Really Need Interfaces for Service and DAO Layers in Spring?
Wukong Talks Architecture
Wukong Talks Architecture
Jun 19, 2024 · Backend Development

Design and Optimization of a High‑Concurrency Lottery System

This article details how a large‑scale lottery service was architected and tuned for extreme traffic spikes by applying server‑side rate limiting, application‑level throttling, behavior‑based filtering, caching strategies, database optimizations, and hardware upgrades, resulting in a ten‑fold performance improvement.

Database TuningHigh concurrencySemaphore
0 likes · 12 min read
Design and Optimization of a High‑Concurrency Lottery System
iQIYI Technical Product Team
iQIYI Technical Product Team
Jun 14, 2024 · Operations

Stability Assurance Practices for the 2024 CCTV Spring Festival Gala Live Stream

The 2024 CCTV Spring Festival Gala live stream employed comprehensive stability assurance practices across signal encoding, CDN distribution, request handling, and playback—using multi‑source encoding, multi‑level origin redundancy, multi‑cluster HA, and P2P‑augmented delivery—to handle massive QPS spikes, ensure high availability, and provide a resilient, high‑quality viewing experience.

CDNHigh AvailabilityP2P
0 likes · 24 min read
Stability Assurance Practices for the 2024 CCTV Spring Festival Gala Live Stream
Architect's Guide
Architect's Guide
Jun 13, 2024 · Databases

Cache Consistency Between MySQL and Redis: Design Patterns and Best Practices

This article explains the relationship between MySQL and Redis, discusses why cache consistency is challenging, and details four cache update design patterns—delete‑then‑update, update‑then‑invalidate (Cache‑Aside), read/write‑through, and write‑behind—illustrating each with flow diagrams and practical considerations.

Cache Design PatternsCache consistencyRedis
0 likes · 7 min read
Cache Consistency Between MySQL and Redis: Design Patterns and Best Practices
JD Tech
JD Tech
Jun 6, 2024 · Operations

Analyzing Service Granularity and Consolidation in Promise Microservices

This article examines the challenges of service proliferation in a microservice‑based system, defines modularity and granularity, and presents systematic splitting and merging factors—such as responsibility, fault tolerance, performance, scalability, cost‑benefit, and team size—using a concrete Promise service case study to guide optimal service design.

Service Splittingbackend-architectureservice granularity
0 likes · 17 min read
Analyzing Service Granularity and Consolidation in Promise Microservices
Top Architect
Top Architect
Jun 3, 2024 · Backend Development

Key Components of a Microservice Architecture: Nginx, Gateway, Service Registry, Cache, Database, Messaging, Logging, Scheduling, and Object Storage

The article outlines a comprehensive microservice architecture by describing essential backend components such as Nginx as the traffic entry, Spring Cloud Gateway, service registries like Nacos, Redis caching and distributed locks, MySQL persistence, Elasticsearch, message queues, ELK logging, distributed schedulers, and object storage solutions, while also noting related tooling and best‑practice considerations.

NGINXService Registrybackend-architecture
0 likes · 11 min read
Key Components of a Microservice Architecture: Nginx, Gateway, Service Registry, Cache, Database, Messaging, Logging, Scheduling, and Object Storage
Bilibili Tech
Bilibili Tech
May 31, 2024 · Backend Development

Design and High‑Availability Practices of Bilibili's Video Submission System

Bilibili’s video submission platform uses a layered micro‑service architecture with a DAG‑based scheduler, extensive observability, and HA tactics such as sharding, 64‑bit ID migration, full‑link stress tests, chaos engineering, and multi‑active data‑center deployment, while tooling like trace correlation and automated alerts ensures stability and guides future hybrid‑cloud migration.

BilibiliDAGHigh Availability
0 likes · 35 min read
Design and High‑Availability Practices of Bilibili's Video Submission System
Su San Talks Tech
Su San Talks Tech
May 30, 2024 · Backend Development

Why Single‑Server Apps Fail: Master Load Balancing with Nginx and LVS

This article walks through the evolution from a single‑Tomcat deployment to a multi‑layer load‑balancing architecture using Nginx, a gateway, LVS, and DNS, explaining static‑dynamic separation, high‑availability strategies, and performance trade‑offs for scalable backend systems.

High AvailabilityLVSNGINX
0 likes · 11 min read
Why Single‑Server Apps Fail: Master Load Balancing with Nginx and LVS
Architect
Architect
May 28, 2024 · Backend Development

Mastering Microservice Architecture: Key Components and Best Practices

This article provides a comprehensive overview of a typical microservice architecture, detailing the roles of Nginx as the traffic entry, gateways, business services, service registries, caching, databases, messaging, logging, scheduling, and distributed storage, and offering practical guidance for high‑availability deployment.

MicroservicesNGINXService Registry
0 likes · 10 min read
Mastering Microservice Architecture: Key Components and Best Practices
iQIYI Technical Product Team
iQIYI Technical Product Team
May 24, 2024 · Operations

High Availability and Disaster Recovery Practices of iQIYI's Video Relay Service (VRS)

iQIYI’s Video Relay Service ensures uninterrupted video playback by employing a two‑region, three‑center hybrid cloud architecture, multi‑layer storage, cross‑AZ retry mechanisms, protective rate‑limiting and degradation paths, layered monitoring, and rigorous stress‑testing and chaos engineering to achieve high availability and disaster recovery.

Cloud NativeDisaster RecoveryHigh Availability
0 likes · 18 min read
High Availability and Disaster Recovery Practices of iQIYI's Video Relay Service (VRS)
dbaplus Community
dbaplus Community
May 8, 2024 · Backend Development

10 Common Pitfalls When Adopting Spring Cloud Alibaba Microservices (And How to Avoid Them)

The article shares ten real‑world problems encountered in a Spring Cloud Alibaba microservice project—ranging from poor service decomposition and shared databases to chaotic configuration, unnecessary components, and deployment mistakes—offering insights to help teams prevent similar pitfalls.

MicroservicesSpring Cloud Alibababackend-architecture
0 likes · 7 min read
10 Common Pitfalls When Adopting Spring Cloud Alibaba Microservices (And How to Avoid Them)