This article explains why large codebases should be split into distributed services, how to perform the split, the role of Dubbo in RPC communication, and provides practical tips for interviewers and candidates tackling system‑splitting questions.
The article describes how Gaode refactored its multi‑endpoint car‑networking services by replacing duplicated REST APIs with atomic GraphQL‑driven services orchestrated through an API gateway, using a lightweight DSL and plugins to handle non‑business concerns, achieving ~60% reduction in custom code and faster development.
This article explains MX Player’s recommendation indexing architecture, detailing batch and incremental build processes, real‑time and Falcon monitoring, Redis storage design, and how these components together improve system stability, reduce latency, and enhance user experience.
In an interview, Tencent senior engineer Zhou Zijie explains how the new real‑time data push service for Mini Program Cloud Development monitors cloud‑database changes and reliably streams updates to mini‑apps via a three‑layer SDK‑middleware‑backend architecture that uses sequential numbering, TARS RPC, and extensive optimizations to achieve low latency, high concurrency, and will launch publicly in August.
This article explains why a task center is essential for merchants, outlines its goals, and details the backend architecture—including atomic APIs, Apollo-driven dynamic configuration, idempotent control, workflow orchestration, caching, and asynchronous logging—while also sharing future enhancements.
This article examines Netflix's evolution from a monolithic platform to a resilient microservice ecosystem on AWS, detailing the architectural layers, key pain points like service failures and data consistency, and the engineering solutions—including circuit breakers, fault‑injection testing, distributed caching, and automated deployment pipelines—that enable massive scale and high availability.
This article presents a comprehensive design for a flash‑sale (seckill) system that handles massive simultaneous requests by combining load balancing, distributed locking, message queues, cache strategies, and fault‑tolerant deployment, and includes a complete Spring Boot code example with detailed architectural diagrams.
The article recounts Medium's transition from a monolithic Node.js application to a microservice architecture, explaining the motivations, core design principles, practical strategies, tooling choices, and lessons learned to avoid common pitfalls and improve development velocity and system reliability.
This article details how MaFengWo redesigned its membership system—introducing a SKU‑based identity model, a four‑layer service architecture, performance‑focused concurrency controls, and risk‑mitigation mechanisms—to support a richer, more flexible user experience in the post‑traffic‑bonus era.
This article details Ctrip's Order Index (OI) service evolution from version 1.0 to 2.0, describing the original architecture, its limitations, the redesign of data synchronization, job scheduling, and query engines, and the resulting platformization that enables faster, more flexible order aggregation across dozens of business lines.
This article details the architectural design, technical challenges, and iterative evolution of Zhihu's massive read‑service, covering early Bloom‑filter solutions, the RBase cache‑through system, high‑availability and performance optimizations, and the final migration to TiDB for cloud‑native scalability.
This article explains why shadow links are essential for safe load testing in model middle platforms, how to isolate traffic using shadow tables, and provides a step‑by‑step implementation guide including interface analysis, data preparation, nginx configuration, and risk considerations.
The article explains why message queues are employed for decoupling, asynchronous processing, and load‑shedding, outlines their advantages and disadvantages, and compares popular MQ products such as Kafka, ActiveMQ, RabbitMQ, and RocketMQ to guide technology selection.
The article details the evolution of MaFengWo's payment center from a basic payment‑refund module (1.0) to a comprehensive, modular platform (2.0), describing its core capabilities, layered architecture, customizable checkout, routing management, monitoring system, and future micro‑service roadmap.
The article details NetEase Open Courses’ feed‑stream architecture, describing how content ingestion, multi‑level filtering, vertically and horizontally split storage, Elasticsearch indexing, two‑tier caching, and micro‑service orchestration combine to deliver personalized, high‑availability course feeds while addressing scalability, consistency, and operational challenges.
This article uses Taobao as a case study to trace the evolution of its server‑side architecture from a single‑machine setup to a cloud‑native, micro‑service ecosystem, detailing each scaling milestone, the technologies involved, and the design principles that guide high‑availability, high‑concurrency systems.
This article categorizes high‑concurrency challenges into read‑heavy and write‑heavy scenarios and presents practical strategies such as caching, sharding, asynchronous processing, batch operations, and architectural patterns to improve scalability and performance of backend systems.
The article presents a detailed analysis of Weibo's short‑video platform architecture, covering team background, business scenarios, micro‑service design, feed‑pull model, multi‑level distributed caching, multi‑datacenter HA deployment, circuit‑breaker mechanisms, and elastic scaling to achieve high availability under unpredictable traffic spikes.
This article explains why cache clusters are essential, describes the problems caused by hot keys and large values, and presents a multi‑layer solution using streaming analytics, automatic hotspot detection, local JVM caching, and rate‑limiting to keep backend systems stable under massive traffic spikes.
This article explains how MaFengWo built a data‑driven AB testing platform using OpenResty, MurmurHash, and a three‑tier cache to achieve low‑latency, high‑throughput traffic splitting across web, app, and micro‑service environments.
This article presents the architecture and key design features of WOS, the 58 Group’s self‑developed object storage system, covering its overall framework, proxy, store, directory, detector modules, fast‑upload “秒传” mechanism, and erasure‑coding solution for efficient, scalable, and reliable unstructured data storage.
This article analyzes the business flow of flash‑sale (seckill) activities, identifies the high‑concurrency technical challenges, and presents a comprehensive backend architecture—including frontend static page handling, request throttling, service‑layer queuing, database sharding, caching, optimistic locking, and anti‑cheating measures—to ensure reliability, scalability, and data consistency.
Apollo is a configurable, extensible content‑processing platform that models each step as a node defined in a configuration file, supports multiple implementations for A/B testing, decouples producers and consumers via Kafka, ensures fault‑tolerant retries and replay, captures fine‑grained metrics through Canal‑to‑TiDB pipelines, and cuts new‑type development effort to roughly ten percent of the original cost while delivering high‑quality data to downstream teams.
The article introduces the Cube Model for scalable microservice architectures, explaining how X‑axis (horizontal scaling), Y‑axis (functional decomposition) and Z‑axis (data partitioning and isolation) expansions address capacity, complexity, and differentiated service demands in high‑traffic distributed systems.
This article explains how to determine the appropriate number of microservices for a large system and outlines four practical splitting strategies—by business logic, scalability, reliability, and performance—while emphasizing team size and service granularity to balance maintainability and efficiency.
This article explains the business need, challenges, and detailed backend architecture—including business, technical, and deployment designs—of a high‑concurrency, high‑availability overseas logistics tracking system built with Java, Spring, ActiveMQ, Redis, MySQL, and Docker.
This article reviews a decade‑long evolution of backend engineering—from early LAMP stacks to modern micro‑services, middleware, cloud, big data, AI, and containerization—explaining why new developers need to understand each layer's role in today’s complex internet systems.
This article explores server clustering and load‑balancing fundamentals, detailing how LVS, Nginx, and HAProxy operate at different OSI layers, their deployment scenarios, architectures, modes, strengths, and weaknesses, and offers practical guidance for choosing the right solution in modern backend systems.
This article explores the fundamental design of a message queue system, covering overall architecture with producers, brokers, and consumers, key design considerations for the broker, communication protocols such as JMS and AMQP, storage options, and strategies for managing consumption relationships and advanced features.
The article describes the motivation, analysis, architecture, performance optimizations, development challenges, and future plans of JD Finance’s LEGO backend platform, which uses Spring Boot, SpEL, Redis, and reactive programming to enable dynamic, high‑performance page configuration for a high‑traffic mobile app.
This article explains what microservices truly are, debunks common misconceptions, outlines their key characteristics, discusses pitfalls such as over‑splitting into tiny monoliths, and highlights the importance of automated operations and DevOps practices for successful implementation.
This article provides a comprehensive overview of NSQ, covering its core components, message flow, producer and consumer interactions, key configuration parameters, handling of timeouts, backoff mechanisms, service discovery with nsqlookupd, and practical considerations for scaling and reliability.
The article details the step‑by‑step evolution of the WeChat‑like instant messaging platform at 58 Group, describing how the system transitioned from a simple PHP short‑connection architecture to a layered micro‑service architecture using Java‑based RPC, Go‑based short‑connection services, distributed storage, message queues, and clear separation of storage, logic, and interface layers.
The article explains how G7's Financial Strategy Center unifies risk‑control rules into a strategy platform, detailing its benefits, underlying architecture, rule‑engine processing steps, and the supporting indicator service that together streamline development, deployment, and management of complex financial risk policies.
This article explains the concept of state in software, contrasts stateful and stateless designs, and shows how moving state handling to the client or shared storage improves scalability, fault tolerance, and maintainability in distributed backend systems.
This article introduces a series of microservice design patterns—including database isolation, observability, and cross‑cutting concerns—explaining the underlying problems each pattern solves and providing concrete solutions such as CQRS, Saga, log aggregation, health checks, and blue‑green deployments.
This article introduces microservice architecture design patterns, covering core architectural principles, decomposition approaches such as business‑capability, sub‑domain, and strangler patterns, and integration solutions like API‑gateway, aggregator, and client‑side UI composition, while highlighting common challenges and their remedies.
This article introduces key microservice design patterns, covering decomposition approaches such as business‑capability and sub‑domain splits, the Strangler pattern, and integration solutions like API‑gateway, aggregator, and client‑UI composition, while outlining core microservice principles and challenges.
Designing high‑concurrency applications requires adopting stateless services, modular decomposition, service‑oriented architecture, message queues, data heterogeneity handling, multi‑layer caching, and parallel processing, each illustrated with practical e‑commerce examples that balance scalability, fault tolerance, and eventual consistency.
This article explains how to move beyond naive copy‑paste development of lottery back‑ends by abstracting business logic into a reusable platform, covering database sharding, micro‑service architecture, common and custom modules, performance, deployment, and security considerations for a robust, SaaS‑like solution.
The article details the design principles, layered traffic allocation model, architecture, data processing pipeline, and operational experience of the AB experiment platform used at Beike Zhaofang, highlighting its web, API, and storage layers, gray‑release capabilities, current limitations, and future improvements.
This article explains how JD Daojia's location system, which powers store discovery and distance calculations for its O2O platform, has evolved through multiple architectural stages, addressed precision and performance challenges, and been optimized with indexing, Mercator projection, and traffic‑shaping techniques to achieve stable, high‑availability service.
This article explains a practical, simplified microservices architecture that focuses on essential components such as service registry, discovery, load balancing, and API gateways, and provides step‑by‑step guidance on implementation, deployment, and operations to improve development speed, maintainability, and scalability for typical enterprise projects.
This article explains the difference between rate limiting and circuit breaking, shows how to determine system capacity, compares fixed‑window, sliding‑window, leaky‑bucket and token‑bucket algorithms with code examples, and offers best‑practice guidance for applying them in distributed backend systems.
The article explains how fast iteration, thorough business domain modeling, layered module design, minimal‑responsibility interfaces, and automated exception feedback can together boost backend development productivity and reduce maintenance costs in modern software projects.
This article examines the challenges of Youzan's order export system, describes the migration from PHP‑based scripts to an Elasticsearch and HBase stack, and details the step‑by‑step configuration‑driven refactor—including enum field definitions, Groovy scripts, strategy patterns, plugin architecture, and quality‑assurance practices—that enabled million‑order exports with high performance and stability.
This article details the design and performance optimization of a live quiz platform, covering overall architecture, user info retrieval, answer submission handling, anti-cheating measures, and Tomcat configuration, highlighting techniques such as request distribution, in‑process caching, asynchronous processing, MQ peak‑shaving, and Redis aggregation.
The article details Youzan's three‑stage evolution of its order management system—from database sharding to Elasticsearch‑based cross‑table search and finally HBase for fast detail assembly—while addressing data sync, real‑time consistency, and idempotency strategies.
Medium’s engineering team recounts how they transitioned from a monolithic Node.js app to a microservice architecture, outlining three core design principles, practical strategies for service boundaries, data storage, networking, deployment, monitoring, and how to avoid common microservice pitfalls.
Medium transitioned from a monolithic Node.js app to a microservice architecture by adhering to three core principles—single purpose, loose coupling, and high cohesion—and implementing strategies such as dedicated services, avoiding shared storage, using Service Mesh, gRPC, Kubernetes, and comprehensive monitoring.
This article explains the goals, principles, and practical reasons for moving from a monolithic Node.js application to a microservice architecture, outlining design guidelines and a seven‑point strategy to avoid common pitfalls and improve performance, scalability, and team productivity.
This article explains how to build a high‑concurrency flash‑sale (秒杀) system by separating static page traffic with CDN, using read‑write‑split Redis for early request filtering, applying Lua scripts for atomic inventory deduction, and employing Redis as a simple message queue for asynchronous order persistence.
This article introduces microservice architecture design patterns, covering decomposition and integration patterns, their associated challenges, and practical solutions such as business‑capability decomposition, domain‑driven design, API‑gateway and aggregator patterns, helping developers tackle scalability, resilience, and maintainability in modern backend systems.
In this interview, Weibo’s microservices expert Hu Zhongxiang discusses the advantages of microservice architecture for handling sudden traffic spikes, challenges in implementation, service splitting strategies, the link between microservices and cloud‑native, and offers learning recommendations and insights for the upcoming GIAC conference.
This article explains the concept of a simple microservices architecture, outlines essential components such as service registry, discovery, load balancing and API gateway, compares three load‑balancing approaches, and provides concrete implementation guidance using Eureka, Ribbon, Zuul and related DevOps practices.
This article narrates the step‑by‑step evolution of a cross‑border e‑commerce logistics platform, detailing how its backend architecture was repeatedly redesigned—from a simple 1.0 system to a robust, fault‑tolerant 3.0 solution—driven by growing business needs, performance challenges, and reliability lessons.
This article shares detailed, still‑relevant architectural practices from a 2015 internal JD training PPT, covering service monitoring gaps, stateless design, Nginx + Lua caching, Twemproxy‑Redis sharding, connection management, timeout settings, upstream strategies, Java/Tomcat tuning, and other performance‑optimizing techniques for high‑concurrency e‑commerce systems.
APPKIT is a scalable, JSON‑driven configuration platform that streamlines Meituan and Dazhong Dianping’s mobile operation resources through a three‑stage workflow, SDK‑based caching, and layered architecture, dramatically reducing release cycles, latency, and central‑service load while supporting multi‑platform deployment and robust monitoring.
The article explains the MicroChat instant‑messaging backend architecture, detailing its long‑connection, access, logic, and storage layers, and describes how message synchronization, offline handling, hole‑filling, unread count roaming, and read receipts are implemented and optimized for multi‑device use.
This article presents a comprehensive design of a high‑availability red‑envelope system, covering its data model, generation, distribution, verification, query optimization, and product tagging strategies, while detailing the use of Redis, distributed locks, MQ, and caching to meet complex business scenarios.
The article summarizes a video on Laravel project structuring, explaining how separating responsibilities into layers such as Repository for data access, Service for business logic, Presenter for view preparation, Transformer for data shaping, and Formatter for consistent API responses improves maintainability and scalability.
This case study details how the ZTO “掌中通” courier app transformed its backend from a monolithic architecture to a scalable, high‑availability microservice system using RPC, Dubbo, AKF scalability models, and advanced concurrency techniques.
This article details how Zhongtong's finance‑information department built the Pangu system—a distributed, micro‑service‑based backend leveraging sharding, Elasticsearch, Kafka‑like messaging, and Hadoop—to handle over a billion daily scan records, achieve real‑time billing, and support multi‑year growth.
This article describes the end‑to‑end evolution of a large‑scale order dispatch architecture, covering the shift from simple pool display to algorithmic assignment using data mining, genetic algorithms, timing‑wheel scheduling, and a Redis‑backed implementation to improve delivery efficiency and rider experience.
The article examines the pressures on Toutiao's architecture, outlines its three-stage evolution from a simple three‑tier system to a split architecture and finally microservices, and details the service‑registration, authorization, and custom RPC framework that enable rapid, reliable backend development.
This article explores practical Domain‑Driven Design in a B‑to‑B setting, comparing data‑centric and object‑centric modeling, illustrating blood‑loss, anemia, and rich models, and showing how dependency injection, testing strategies, repository abstractions, and deployment architectures can improve software quality and maintainability.
The article outlines the defining traits of large‑scale websites—high concurrency, massive traffic, high availability, and huge data volumes—and explains how their architecture evolves from a single‑server setup to layered, distributed systems using caching, load balancing, database read/write splitting, CDN, NoSQL, and service isolation.
The article explains the concept of service isolation, its origins in shipbuilding, why it’s crucial for reducing fault impact in software systems, practical approaches such as functional and user‑based isolation, their trade‑offs, and key design principles to ensure reliable, maintainable back‑end architectures.
This article outlines ten crucial design principles for building robust microservice systems, covering API gateways, stateless services, database scaling, caching, service splitting, orchestration, configuration management, logging, resilience patterns, and comprehensive monitoring to ensure high performance and reliability.
This article outlines six fundamental microservice design patterns—Aggregator, Proxy, Chain, Branch, Data‑Sharing, and Asynchronous Messaging—explaining their structures, use‑cases, scalability characteristics, and potential pitfalls to help architects choose the right approach for their systems.
This article explains why clear application layering matters, outlines Alibaba's recommended layer structure, proposes an optimized layering model with distinct responsibilities, and details domain model conventions to improve code reuse, maintainability, and team collaboration in backend development.
This article explains why growing business complexity and throughput demands force system decoupling and architectural upgrades, then details practical approaches to system splitting—including horizontal scaling, vertical and business partitioning—and describes the subsequent structural evolution with caching, sharding, and micro‑service patterns.
This article explains the principles of the Facade, Observer, Command, and Chain of Responsibility design patterns, illustrates how Tomcat implements each with class diagrams and code snippets, and shows how these patterns help organize subsystems, manage events, delegate actions, and streamline request processing in a Java server.
This article explores Tomcat’s modular design, detailing the roles of Service, Connector, Container, Server, and Lifecycle interfaces, and illustrates how requests flow through the servlet engine with code examples and component diagrams.
The article shares Zhihu's multi‑year journey toward service‑oriented architecture, discussing the motivations, practical challenges, design trade‑offs, and lessons learned from microservice, RPC, and SSO‑based vertical splitting, as well as guidelines for defining service boundaries and layering.
This article provides a comprehensive overview of Alibaba's open‑source Dubbo framework, detailing its ten‑layer architecture, the roles of providers and consumers, service registration, monitoring, protocol support, and the organization of its Maven modules for building distributed backend services.
This article presents a comprehensive design of a flash‑sale (seckill) architecture, covering business characteristics, user scale, layered system components, optimization strategies, full‑link stress testing, and a complete SpringBoot code example with distributed locks, message queues, and database sharding.
This article examines the evolution of QTalk’s instant messaging platform, detailing its original centralized design, the motivations for decentralization, the new architecture with domain and public services, security benefits, deployment strategies, and real-world use cases, illustrating how a scalable, secure IM solution can be built for enterprise environments.
The article explains how the slowdown of Moore's Law drives the shift from monolithic applications to distributed systems, covering load balancing, session handling strategies, read‑write separation, and database sharding to achieve scalable, high‑availability backend architectures.
The article outlines how Tmall’s product‑detail service evolved through three architectural phases—system staticization, unified web caching, and CDN staticization—to handle Double‑11 traffic spikes with cost‑effective scalability, high availability, and improved performance.
This article reviews essential concepts of message queue middleware, covering why to use queues, their drawbacks, selection criteria, high‑availability strategies, deduplication, reliable transmission, ordering guarantees, and practical advice for interview preparation.
This article presents a practical, China‑focused microservice reference stack built on Spring Cloud, detailing core support components such as Zuul, Eureka, Apollo, and Spring Boot, as well as monitoring tools like Kafka, ELK, CAT, KairosDB, ZMon, and Hystrix, and explains when and how to apply each in production environments.
The talk details Tencent Xinge’s architecture and cloud‑native practices that enable hundred‑billion‑level mobile push, combining terminal integration, real‑time backend filtering, distributed bitmap selection, precise‑push AI models, and DevOps pipelines to deliver fast, scalable, data‑driven notifications with effect tracking.
This article presents a practical, China‑centric microservices reference stack built on Spring Cloud, detailing eleven core components—including Zuul, Eureka, Apollo, Kafka, ELK, and Hystrix—while comparing them with alternatives and offering guidance for architects to avoid common pitfalls and accelerate production‑grade deployments.
This article details the design of a unified MySQL data synchronization platform that consolidates offline sync, real‑time subscription, and real‑time sync into BatchJob, StreamJob, and PieJob abstractions, describing task implementations, cluster architecture, high‑availability mechanisms, and evolution challenges such as file loss and metadata handling.
This article explains how modular design and service extraction can reduce system complexity and improve reusability, illustrates practical before‑and‑after examples for red‑packet and notification services, and details high‑concurrency techniques such as caching, asynchronous processing, rate limiting, service degradation, anti‑fraud measures, and concurrency‑safe database operations.
This article outlines practical strategies for building high‑concurrency back‑end systems—including server architecture, load balancing, database clustering, caching, message queues, asynchronous processing, and service‑oriented design—to ensure smooth operation of traffic‑intensive e‑commerce services.
The article explains how to design a backend architecture that can handle millions of concurrent requests by applying principles such as service decomposition, high availability, idempotent business logic, and various rate‑limiting algorithms—including sliding window, leaky bucket and token bucket—with a runnable Java demo.
This article details the three‑stage evolution of Ctrip's image service architecture—from an early NFS‑backed design with Squid caching, through a Varnish‑and‑Lua powered middle stage, to the current Go‑based multi‑process system using FastDFS—highlighting the challenges, solutions, and performance outcomes.
This article details Snowball's evolution from a third‑party fund trading platform to a self‑developed backend system, covering business flow, architectural redesign, phased user migration, payment channel optimization, and the operational benefits achieved through the new solution.
The article examines the advantages and drawbacks of microservices versus monolithic architectures, outlines key factors that influence the decision to split, and walks through a real‑world shared‑points project, detailing a four‑step process for decomposing a monolith into independent services.
This article walks through the step‑by‑step evolution of a Java website—from a single‑machine setup to a multi‑tier, load‑balanced, sharded, cached, and service‑oriented architecture capable of handling billions of requests—detailing the challenges and solutions at each stage.
This article explains how a three‑layer caching architecture—combining Nginx, Redis, and Ehcache—along with template engines, double‑Nginx routing, persistence mechanisms, cluster setups, and various cache‑update strategies can dramatically improve hit rates, reduce database pressure, and prevent cache‑related failures in high‑traffic applications.
This article shares a seasoned developer’s perspective on selecting a message‑queue middleware, outlining typical adoption stages, three key evaluation criteria—coder expertise, current and future requirements, and community/ecosystem health—and offering candid advice on avoiding common pitfalls.
The article explains how Alibaba’s TMF 2.0 framework tackles massive transaction‑peak challenges by introducing visual, configurable, and manageable business definitions through a plug‑in architecture, unified business identity, and a clear separation of management and runtime domains.
This article explains what a flash‑sale (秒杀) is, outlines its technical challenges such as massive concurrency and database load, and presents practical strategies and architectural designs—including independent deployment, static pages, CDN bandwidth leasing, dynamic URL generation, and order‑handling mechanisms—to reliably support ultra‑high traffic spikes.
This article explores the defining traits of large‑scale websites and walks through the step‑by‑step evolution of their architecture—from single‑server setups to distributed systems with caching, load balancing, database sharding, and micro‑services—while highlighting common design pitfalls and best‑practice recommendations.
This article details the redesign of a TV app from a horizontal layout to a waterfall flow, explaining the project timeline, advantages, new seven‑layer architecture, CMS‑driven configuration, compatibility handling, pagination strategies, caching, and fault‑tolerance measures that together improved user conversion and system robustness.
This article traces Alibaba's e‑commerce technical evolution—from early LAMP‑based monoliths through Java‑centric 2.0 systems to a massive multi‑IDC, service‑oriented distributed architecture with HSF, Pandora, and advanced database sharding solutions—highlighting the challenges and innovations that enabled its massive scalability.
This article walks through the evolution from traditional three‑layer monolithic architecture to microservice architecture, explaining system design concepts, the drawbacks of monoliths, the benefits and challenges of microservices, and compares them with SOA, providing clear diagrams, pros and cons, and practical insights for backend engineers.
