This article explains the design and implementation of an ABT (Auto‑Bidding Test) system that automates A/B decision cycles, covering client SDK architecture, protocol specifications, data‑point collection, resource‑placement experiments, and home‑page integration to accelerate product growth.
This article walks through the step‑by‑step evolution of a Java‑based e‑commerce platform, illustrating how a single‑machine deployment can be transformed into a scalable architecture using techniques such as server‑database separation, clustering, load‑balancing algorithms, read‑write splitting, caching, sharding, micro‑services and message queues.
This article examines the challenges of building a flash‑sale (秒杀) system—such as overselling, massive concurrent requests, URL exposure, and database overload—and presents a comprehensive backend architecture that leverages Redis clustering, dynamic URLs, Nginx load balancing, rate‑limiting, asynchronous order processing, and service degradation techniques to achieve robust, scalable performance.
This article examines the origins, principles, advantages, and drawbacks of microservice architecture, outlines when it should be adopted, describes its evolution stages, presents design patterns, service‑splitting strategies, and reviews popular frameworks and tools to help teams decide if microservices fit their system complexity and organizational capabilities.
The article details the design principles, modular architecture, and engineering optimizations of a backend algorithm platform that uses APIs, micro‑services, and asynchronous processing to enable fast, reliable, and scalable online algorithm services, including recall, ranking, metadata, feature reporting, and A/B testing.
This article explores the design of a high‑performance short‑link system, covering its benefits, redirection mechanics, hash‑based and auto‑increment generation methods, database schema, Bloom filter optimization, and a scalable OpenResty‑based architecture for handling massive traffic.
From the manual offline 1.0 system to the real‑time, AI‑driven Hermes platform, Xianyu Push evolved through 1.1’s richer feed layout, personalized timing, and IFTTT‑style triggers, ultimately delivering higher click‑through rates, broader scene coverage, and stronger daily active user activation.
The article summarizes Xu Wenqi's 2019 Alibaba Cloud Summit talk on Ant Financial's distributed architecture, covering the shift from monolithic to microservices, modular development, load‑balancing, database sharding, the distributed TA system, task scheduling, gray‑release, full‑link stress testing, and OceanBase high‑availability solutions.
This article explains how Alibaba's entertainment cloud platform designs layered backend architecture, hotspot data isolation, flow‑shaping funnels, multi‑level caching, and comprehensive stability measures to support ultra‑high‑concurrency ticket sales while preventing oversell and ensuring system reliability.
This article examines microservice decomposition by presenting three expert‑derived splitting approaches—vertical/horizontal, business‑driven cost‑aware, and responsibility‑based—and discusses how factors such as team size, maintenance cost, scalability, stability, reliability and performance influence the optimal service boundaries.
This article chronicles Yuque's evolution from a 2016 internal prototype to a fully commercialized knowledge‑base platform, detailing its JavaScript full‑stack architecture, migration from BaaS to IaaS, adoption of microservices and serverless functions, and the security and stability practices that support its growth.
This article details Hema's approach to guaranteeing system stability for its offline and delivery operations, covering the complete smart‑dispatch architecture, exhaustive dependency analysis, database and middleware safeguards, monitoring strategies, gray‑release practices, testing methods, and emergency response procedures that together enabled a year of zero failures.
This article details the design, algorithm selection, and performance optimizations behind a geospatial photo‑indexing service that aggregates and searches millions of user photos by location and time, enabling faster, more accurate travel content sharing in a mobile app.
This article explains the conceptual differences between SOA and microservice architectures, compares ESB with API gateways, outlines the characteristics of each approach, and provides practical guidelines for designing and managing Dubbo services in a distributed backend system.
The document outlines the design, key components, data flow, and operational strategies of a large‑scale message push platform, detailing its architecture, request handling, long‑connection management, retry mechanisms, data statistics, monitoring, and future expansion plans.
This article examines how to locate the free‑shipping feature‑flag decision in an e‑commerce system, arguing that the decision should be made at the web‑layer where user context is available and then passed to the checkout service, keeping each service focused on its core responsibilities.
This article examines the key challenges of flash‑sale (秒杀) systems—overselling, massive concurrency, URL exposure, and database coupling—and presents a complete backend design featuring dedicated databases, dynamic URLs, static pages, Redis clustering, Nginx proxy, rate‑limiting, token‑bucket control, asynchronous order queues, and service degradation strategies.
The article summarizes Zhu Qingjie’s presentation on JD.com’s core transaction platform, highlighting its massive scale, stringent high‑concurrency and high‑availability requirements, architectural strategies such as system splitting, caching and componentization, and the use of an autonomous decision platform to ensure rapid, reliable e‑commerce operations.
This article examines the challenges of designing a robust flash‑sale backend—preventing oversell, handling massive concurrent requests, securing URLs, isolating databases, and applying techniques such as Redis clustering, Nginx load balancing, rate limiting, asynchronous processing, and service degradation—to enable stable, low‑latency sales spikes.
This article analyzes the core challenges of building flash‑sale (秒杀) systems—high concurrency reads and writes, strict consistency, and ultra‑high availability—and presents a layered architectural approach covering dynamic/static separation, hotspot optimization, database tuning, and comprehensive high‑availability strategies.
This article explains how Youku built and iterated its Demand‑Side Platform, covering business goals, system architecture, channel integration, bidding and frequency strategies, material selection, smooth budget delivery, retargeting, algorithmic recall, data monitoring, and conversion‑funnel optimization to drive user growth.
The article outlines Taobao's backend architecture evolution—from a single Tomcat‑MySQL server through caching, load‑balancing, database sharding, MPP, DNS‑based multi‑datacenter routing, NoSQL/search integration, microservices, ESB, containerization, and finally cloud‑native deployment—while summarizing the associated technologies and design principles.
This article uses Taobao’s backend as a case study to illustrate how server architecture evolves through ten stages—from a single‑machine setup handling hundreds of requests to a distributed, containerized, cloud‑native system supporting tens of millions of concurrent users—detailing the technologies and design principles at each step.
The article details how Yu'ebao, a financial platform with over five hundred million users and assets exceeding one trillion yuan, designs and operates a comprehensive service‑governance framework—including metrics collection, bi‑weekly governance committee reviews, dynamic and static call‑chain analysis, and layered service architecture—to balance security, compliance, and rapid service delivery.
This article explains how to design a high‑concurrency flash‑sale (秒杀) system by leveraging browser and CDN caching, read‑write split Redis for traffic filtering, Lua scripts for atomic stock deduction, master‑slave Redis for fast inventory updates, and Redis‑based message queues for asynchronous order processing.
This article outlines Alibaba's middle‑platform strategy, detailing the layered IT architecture, the evolution from IOE to distributed services and platformization, the practical methodology for building, governing, and evolving a business middle platform, and key takeaways for enterprises seeking large‑scale system governance.
This article outlines eight core principles for designing a business middle platform, covering service loose coupling, dependency management, design guidelines, naming, granularity, statelessness, operation design, and constraint rules to ensure scalable, maintainable, and business‑aligned services.
Facing tangled microservice calls and heavy front‑end data stitching, Fangdd’s engineering team evolved from monolithic PHP to a multi‑layered microservice architecture, introducing Duo‑GraphQL to unify data via GraphQL providers, a BFF layer, and optimized engine, dramatically improving development speed and performance.
This article walks through constructing a lightweight instant‑messaging backend, covering version 1.0.0 features, reliability guarantees, application‑level ACK handling, security encryption, database schema for users, relations and offline messages, and storage strategies to prevent duplicate delivery.
This article examines the challenges of high‑traffic live‑streaming instant messaging, presents the original V1 TCP‑based architecture, explains its performance bottlenecks, and details the redesigned V2 solution that adopts Netty, protobuf, compression, and RPC to dramatically reduce bandwidth and latency while supporting millions of concurrent users.
Alibaba’s 10‑year‑old search engine combines data source aggregation, incremental and real‑time indexing, and online services through platforms like Tisplus, Bahamut, Maat, Ha3, Build Service and Drogo, illustrating a comprehensive architecture that powers 1688’s search capabilities across multiple engines and deployment pipelines.
This article explains what technical architecture is, breaks down its three core components—business technical problems, technical solutions, and technical components—and then dives deep into high‑concurrency challenges, systematic thinking methods, and practical approaches such as resource scaling, stateless design, load balancing, caching, and I/O optimization.
This article explains the essence of scalability as a placeholder concept, outlines a four‑step method—standardize, identify, register, use—and demonstrates its application through Java SPI and a coupon platform case study to design extensible backend systems.
The article explains how to handle massive simultaneous user requests in a flash‑sale scenario by using rate limiting, caching, asynchronous processing, distributed locks, load balancing, and anti‑cheat mechanisms, illustrated with the Sohu Focus online opening system architecture.
The article describes a stable withdrawal system that integrates UnionPay and WangLian, emphasizing immutable serial numbers, strict exception handling, real‑time monitoring, multi‑stage compensation, a database‑driven routing engine handling up to 500 k transactions per hour, and an operations console for manual recovery, while outlining future optimizations.
This article outlines how large‑scale web applications evolve from simple single‑server deployments through static‑dynamic separation, clustering, database read/write splitting, sharding, service‑oriented architecture, and message queues, emphasizing the trade‑offs and best practices for each architectural stage.
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.
