BestHub
Sign in
Tagged articles

Backend Architecture

980 articles · Page 10 of 10
Architecture Digest
Architecture Digest
Jul 6, 2016 · Backend Development

Designing a Message Queue: Key Considerations and Architecture

The article explains why and when to use message queues, then walks through designing one from scratch, covering decoupling, eventual consistency, broadcast, flow control, RPC protocols, high availability, storage choices, consumer relationships, reliable delivery, transactions, performance optimizations, and push versus pull models.

AsynchronousBackend ArchitectureMessage Queue
0 likes · 35 min read
Designing a Message Queue: Key Considerations and Architecture
dbaplus Community
dbaplus Community
Jun 19, 2016 · Backend Development

Beyond Cache+Hash: Real Strategies for Building High‑Concurrency Systems

This article demystifies the common belief that cache‑plus‑hash alone solves high‑concurrency challenges, explores essential techniques such as static resource serving, read‑write separation, advanced caching, hash‑based sharding, and especially the design trade‑offs of various Trie‑based data structures for search‑suggestion services, and offers practical optimization steps.

Backend ArchitectureHashingTrie
0 likes · 28 min read
Beyond Cache+Hash: Real Strategies for Building High‑Concurrency Systems
Architecture Digest
Architecture Digest
Jun 5, 2016 · Backend Development

Web System Load Balancing, Caching, and Scaling Strategies for High Traffic

This article explains how to design and optimize web system architecture—including load‑balancing methods, multi‑level caching, MySQL scaling, distributed deployment, and disaster‑recovery techniques—to handle traffic growth from hundreds of thousands to hundreds of millions of daily visits.

Backend ArchitectureLoad BalancingMySQL
0 likes · 19 min read
Web System Load Balancing, Caching, and Scaling Strategies for High Traffic
dbaplus Community
dbaplus Community
May 25, 2016 · Backend Development

How Adding a Distributed Memcache Layer Cut Database Load by 30% in a Telecom CRM

A telecom CRM project introduced a horizontally scalable Memcache cache layer to store frequently accessed dictionary and customer data, reducing database queries by 30%, improving response times by 15%, and lowering expansion costs while detailing the architecture, access logic changes, high‑availability measures, and real‑world results.

Backend Architecturedistributed cachingmemcache
0 likes · 13 min read
How Adding a Distributed Memcache Layer Cut Database Load by 30% in a Telecom CRM
Java High-Performance Architecture
Java High-Performance Architecture
May 25, 2016 · Backend Development

How imgix Scales Real‑Time Image Processing with a Custom Backend Architecture

The article explains how imgix delivers real‑time image manipulation via URL parameters, outlines its evolution from Amazon EC2 to a proprietary processing center using Apple Core Graphics on Mac hardware, and details the backend services, load balancing, logging, and infrastructure that enable processing up to 100,000 images per second.

Backend ArchitectureCloud InfrastructureReal-time Delivery
0 likes · 5 min read
How imgix Scales Real‑Time Image Processing with a Custom Backend Architecture
Hulu Beijing
Hulu Beijing
May 19, 2016 · Backend Development

How Hulu Evolved Its Video Platform Across Three Generations

This article chronicles Hulu's video system evolution from a Flash‑based player to HLS/H264 multi‑platform support and finally to an MPEG‑DASH architecture, detailing technical choices, DRM challenges, workflow simplifications, and the comprehensive backend and monitoring infrastructure that enable seamless multi‑device streaming.

Backend ArchitectureDRMFlash
0 likes · 10 min read
How Hulu Evolved Its Video Platform Across Three Generations
21CTO
21CTO
May 14, 2016 · Backend Development

How We Scaled a Billion‑User System: From Monolith to Microservices

This article recounts how a rapidly growing online platform transformed a tightly coupled, fragile architecture into a scalable, high‑availability system by applying dynamic/static separation, read‑write splitting, caching, load‑balancing, intelligent monitoring, and finally migrating to a micro‑service architecture.

Backend ArchitectureCloud NativeMicroservices
0 likes · 11 min read
How We Scaled a Billion‑User System: From Monolith to Microservices
Big Data and Microservices
Big Data and Microservices
May 12, 2016 · Industry Insights

How 58 Daojia Built a Scalable Real‑Time Messaging Platform: Architecture Deep Dive

This article dissects the design of 58 Daojia’s universal real‑time messaging platform, detailing the challenges of end‑to‑cloud, cloud‑to‑end, and end‑to‑end communication, the shortcomings of traditional HTTP and push solutions, and the optimized TCP, message‑bus, RPC, and protocol extensions that achieve scalability, reliability, and cross‑account chat.

Backend ArchitectureMessage QueueReal-time messaging
0 likes · 12 min read
How 58 Daojia Built a Scalable Real‑Time Messaging Platform: Architecture Deep Dive
Big Data and Microservices
Big Data and Microservices
May 11, 2016 · Backend Development

How to Build a Scalable Flash‑Sale System that Handles Massive Traffic

This article analyzes flash‑sale (抢购) business scenarios, outlines a layered architecture separating business and data layers, explains decoupling front‑end pressure, uses Redis‑based queues and caching to manage high‑frequency inventory checks, and describes multi‑party reconciliation mechanisms to ensure reliable stock consistency under extreme load.

Backend ArchitectureDatabaseFlash Sale
0 likes · 11 min read
How to Build a Scalable Flash‑Sale System that Handles Massive Traffic
Architecture Digest
Architecture Digest
Apr 28, 2016 · Backend Development

How Twitter Handles 3,000 Images Per Second: Architecture, Scaling, and Media Optimizations

The article explains how Twitter evolved from a text‑only service to a media‑rich platform capable of processing 3,000 images per second by decoupling upload and tweet creation, using handles instead of blobs, implementing resumable segmented uploads, applying TTL policies, and optimizing client‑side formats such as WebP and progressive JPEG.

Backend ArchitectureResumable UploadTwitter
0 likes · 10 min read
How Twitter Handles 3,000 Images Per Second: Architecture, Scaling, and Media Optimizations
21CTO
21CTO
Apr 25, 2016 · Backend Development

Scalable Backend Architecture: Load Balancing, Caching, and Platform Layers

Will Larson’s insights on building scalable systems are distilled here, covering horizontal scalability, redundancy, load balancing strategies, various caching techniques, CDN usage, offline processing with message queues, Map‑Reduce for big data, and the benefits of introducing a dedicated platform layer for robust backend architecture.

Backend ArchitectureLoad BalancingMessage Queue
0 likes · 11 min read
Scalable Backend Architecture: Load Balancing, Caching, and Platform Layers
21CTO
21CTO
Apr 24, 2016 · Backend Development

Inside Sina Weibo’s Third-Gen Backend Architecture for 100M+ Users

To support over 140 million monthly active users, Sina Weibo evolved from a simple LAMP stack to a sophisticated third‑generation architecture featuring layered interfaces, service and resource tiers, custom RPC and messaging frameworks, SSD caching, and a large‑scale distributed tracing system called WatchMan.

Backend ArchitectureMiddlewareScalable Systems
0 likes · 11 min read
Inside Sina Weibo’s Third-Gen Backend Architecture for 100M+ Users
Architect
Architect
Apr 21, 2016 · Backend Development

Reducing Integration Cost of a Message Bus through Dependency Transfer

This article examines how to lower the overall cost of integrating a message bus into existing legacy systems by shifting dependencies from the bus to a simple HTTP endpoint, using a registry and proxy service to enable passive message delivery.

Backend ArchitectureHTTP endpointIntegration
0 likes · 8 min read
Reducing Integration Cost of a Message Bus through Dependency Transfer
21CTO
21CTO
Apr 19, 2016 · Backend Development

How Alibaba’s Notify and MetaQ Power Massive E‑Commerce Messaging

This article explains the design principles, architecture, and performance optimizations of Alibaba's Notify and MetaQ message middleware, illustrating how they achieve reliable asynchronous communication, high scalability, and low latency for billions of messages during peak e‑commerce events like Double 11.

Backend ArchitectureHigh AvailabilityMessage Queue
0 likes · 14 min read
How Alibaba’s Notify and MetaQ Power Massive E‑Commerce Messaging
Big Data and Microservices
Big Data and Microservices
Apr 12, 2016 · Backend Development

WeChat’s Backend Journey: From Zero to Billions with Scalable Architecture

This article chronicles how WeChat’s backend evolved from a simple messaging prototype to a globally distributed, multi‑data‑center system, detailing its message model, unified sync protocol, three‑layer architecture, platformization, disaster‑recovery design, performance tuning, and emerging resource‑scheduling challenges.

Backend ArchitectureData synchronizationDisaster Recovery
0 likes · 30 min read
WeChat’s Backend Journey: From Zero to Billions with Scalable Architecture
21CTO
21CTO
Apr 5, 2016 · Mobile Development

How Ctrip Scaled Its Travel App with Mobile Architecture and Backend Gateway

This article details how Ctrip transformed its travel app by consolidating product versions, redesigning the wireless backend with a Zuul‑based gateway, decoupling the app engineering into independent modules, implementing extensive performance monitoring, and adopting native plugin and hot‑fix solutions to boost stability and user experience.

Backend ArchitectureGatewayHotfix
0 likes · 10 min read
How Ctrip Scaled Its Travel App with Mobile Architecture and Backend Gateway
21CTO
21CTO
Mar 29, 2016 · Backend Development

Designing a Scalable Notification System: Concepts, Classification, and Implementation Strategies

This article explores the design and implementation of a message/notification system, covering product analysis of existing platforms, message classification, reminder language patterns, push/pull delivery methods, subscription mechanisms, entity modeling, and core behavioral workflows for backend developers.

Backend ArchitectureNotification Systemmessage classification
0 likes · 9 min read
Designing a Scalable Notification System: Concepts, Classification, and Implementation Strategies
dbaplus Community
dbaplus Community
Mar 28, 2016 · Backend Development

How to Keep Cache and Database Consistent: Invalidate First, Serialize Access

This article explains why cache and database can become inconsistent in distributed systems, why the "invalidate‑cache‑then‑write‑DB" rule is preferred, and presents practical serialization techniques—modifying DB and service connection pools—to guarantee per‑key sequential execution while maintaining availability and load balance.

Backend ArchitectureConnection PoolSerialization
0 likes · 11 min read
How to Keep Cache and Database Consistent: Invalidate First, Serialize Access
21CTO
21CTO
Mar 24, 2016 · Backend Development

How to Build a Reliable Java Delayed Queue for Scalable Backend Systems

This article explains the design, architecture, and implementation details of a Java-based delayed queue, covering use cases, core components, message lifecycle, protocol, current topology, shortcomings, and future improvements for reliable backend processing.

Backend ArchitectureDelayed QueueMessage Queue
0 likes · 10 min read
How to Build a Reliable Java Delayed Queue for Scalable Backend Systems
21CTO
21CTO
Mar 24, 2016 · Backend Development

Why Combine PHP Front‑End with Java Back‑End? Benefits, Trade‑offs, and Architecture Insights

This article examines why many web projects pair a fast‑changing PHP front‑end with a stable, high‑performance Java back‑end, outlining each language’s strengths, recent improvements, integration methods, and architectural patterns such as view‑first and RPC/RESTful communication.

Backend ArchitectureMicroservicesWeb Development
0 likes · 14 min read
Why Combine PHP Front‑End with Java Back‑End? Benefits, Trade‑offs, and Architecture Insights
21CTO
21CTO
Mar 23, 2016 · Backend Development

How Uber Scales Its Real‑Time Dispatch System: Backend Architecture Insights

This article examines Uber's rapidly growing real‑time dispatch platform, detailing its geo‑spatial indexing, microservice architecture, fault‑tolerant design, and scaling techniques that enable millions of writes per second and high availability across thousands of nodes.

Backend ArchitectureDispatchMicroservices
0 likes · 18 min read
How Uber Scales Its Real‑Time Dispatch System: Backend Architecture Insights
Architect
Architect
Mar 22, 2016 · Backend Development

Youzan Search Engine Practice – Engineering Part: Architecture, Indexing, and Performance Optimization

This article describes the practical architecture of Youzan's commercial e‑commerce search engine, covering data source integration, distributed real‑time indexing with Elasticsearch, Hadoop and Kafka, advanced search modules, and several performance‑tuning techniques for large‑scale deployments.

Backend ArchitectureElasticsearchIndexing
0 likes · 13 min read
Youzan Search Engine Practice – Engineering Part: Architecture, Indexing, and Performance Optimization
Architecture Digest
Architecture Digest
Mar 22, 2016 · Backend Development

Evolution of LinkedIn’s Backend Architecture: From the Leo Monolith to a Scalable Service‑Oriented Platform

The article chronicles LinkedIn’s journey from a single‑server Leo monolith to a highly distributed, service‑oriented backend architecture, detailing the introduction of member graphs, read‑only replicas, caching layers, Kafka pipelines, Rest.li APIs, super‑blocks, and multi‑data‑center deployments to support billions of daily requests.

Backend ArchitectureKafkaLinkedIn
0 likes · 9 min read
Evolution of LinkedIn’s Backend Architecture: From the Leo Monolith to a Scalable Service‑Oriented Platform
High Availability Architecture
High Availability Architecture
Mar 18, 2016 · Backend Development

High‑Availability Architecture of Upyun Image Processing Service

The article details Upyun's high‑availability image processing architecture, covering workload‑aware system design, custom GmServer implementation, task scheduling, current strengths and limitations, and future directions such as a ServiceServer‑based queue and Docker‑driven dynamic scaling.

Backend ArchitectureDockerHigh Availability
0 likes · 15 min read
High‑Availability Architecture of Upyun Image Processing Service
21CTO
21CTO
Mar 12, 2016 · Backend Development

Designing Scalable Asynchronous Message Queues: Ctrip’s Hermes Architecture Deep Dive

This article examines Ctrip's Hermes asynchronous messaging system, detailing its evolution from a simple Mongo‑backed queue to a broker‑centric, partitioned architecture with lease‑based cluster management, and shares practical techniques for building high‑performance, low‑latency message queues in large‑scale distributed environments.

Backend ArchitectureHermesMessage Queue
0 likes · 21 min read
Designing Scalable Asynchronous Message Queues: Ctrip’s Hermes Architecture Deep Dive
Meitu Technology
Meitu Technology
Mar 11, 2016 · Backend Development

Building a High-Availability PHP Service Architecture for Meipai

The talk explains how Meipai engineered a high‑availability PHP backend—leveraging PHP’s ecosystem while overcoming performance bottlenecks—to reliably serve hundreds of millions of users, detailing the architectural decisions, scaling challenges, and key lessons learned during rapid user growth.

Backend ArchitectureMeipaiPHP
0 likes · 2 min read
Building a High-Availability PHP Service Architecture for Meipai
Qunar Tech Salon
Qunar Tech Salon
Mar 8, 2016 · Backend Development

Practices for Handling High Traffic on JD.com Product Detail Pages

The article details JD.com's technical strategies for scaling product detail pages under massive traffic, covering service decomposition, KV‑based dynamic rendering with Nginx+Lua, unified service gateways, isolation, caching, monitoring, degradation, and performance testing to achieve sub‑50 ms response times.

Backend ArchitectureJD.comLua
0 likes · 16 min read
Practices for Handling High Traffic on JD.com Product Detail Pages
21CTO
21CTO
Mar 7, 2016 · Backend Development

How Meizu Scaled Real‑Time Push to 600 K Messages/min: Architecture, Pitfalls & Solutions

This article details Meizu's real‑time push system handling 25 million online users and 50 billion daily PVs, describing its four‑layer backend architecture, challenges such as power consumption, mobile network instability, massive connections, and the monitoring and gray‑release strategies used to ensure reliability and performance.

Backend ArchitectureLarge Scale MessagingMonitoring
0 likes · 12 min read
How Meizu Scaled Real‑Time Push to 600 K Messages/min: Architecture, Pitfalls & Solutions
21CTO
21CTO
Mar 6, 2016 · Backend Development

How JD Scales Its Product Detail Page for Billions of Views

This article explains JD's technical practices for handling massive traffic on product detail pages, covering front‑end rendering, KV storage, Nginx + Lua dynamic templating, unified service systems, monitoring, caching strategies, service isolation, and automated degradation mechanisms.

Backend ArchitectureFrontend OptimizationProduct Detail Page
0 likes · 17 min read
How JD Scales Its Product Detail Page for Billions of Views
Java High-Performance Architecture
Java High-Performance Architecture
Mar 4, 2016 · Backend Development

Why Service Gateways Are Essential for Scalable Microservice Architectures

The article explains how breaking a monolithic website into independent microservices improves stability, resource utilization, and deployment speed, but introduces client‑side complexity that can be solved by introducing a service gateway to aggregate APIs, enhance security, and simplify maintenance.

API aggregationBackend ArchitectureMicroservices
0 likes · 4 min read
Why Service Gateways Are Essential for Scalable Microservice Architectures
21CTO
21CTO
Mar 3, 2016 · Backend Development

Choosing the Right Load Balancing for Microservices: Centralized, In‑Process, Independent

The article explains three primary load‑balancing and service‑discovery patterns for microservice architectures—centralized external load balancers, client‑side soft load balancing, and independent host‑level LB processes—detailing their mechanisms, advantages, drawbacks, and real‑world examples such as F5/HAProxy, Netflix Eureka/Ribbon, and Airbnb SmartStack.

Backend ArchitectureLoad BalancingMicroservices
0 likes · 5 min read
Choosing the Right Load Balancing for Microservices: Centralized, In‑Process, Independent
Java High-Performance Architecture
Java High-Performance Architecture
Mar 2, 2016 · Backend Development

Centralized, In‑Process, or Independent: Which Microservice Load‑Balancing Works Best?

The article explains three primary load‑balancing and service‑discovery patterns for microservice architectures—centralized external load balancers, client‑side soft load balancing, and independent LB processes—detailing their mechanisms, advantages, drawbacks, and real‑world examples such as Netflix Eureka, Dubbo, and Airbnb SmartStack.

Backend ArchitectureCloud NativeLoad Balancing
0 likes · 6 min read
Centralized, In‑Process, or Independent: Which Microservice Load‑Balancing Works Best?
21CTO
21CTO
Feb 16, 2016 · Backend Development

Rethinking 12306 Ticketing: A Domain‑Driven Design Model for Complex Train Reservations

This article analyses the unique business complexity of China's 12306 railway ticketing system, proposes a domain‑driven aggregate design centered on the train route, explains how to model seat availability and ticket issuance, and outlines a CQRS/event‑sourcing architecture to achieve strong consistency and high concurrency.

Backend ArchitectureDDDDomain-Driven Design
0 likes · 25 min read
Rethinking 12306 Ticketing: A Domain‑Driven Design Model for Complex Train Reservations
Java High-Performance Architecture
Java High-Performance Architecture
Feb 14, 2016 · Backend Development

Why Distributed Message Queues Are Essential for Scalable Systems

The article explains the core concepts of message queues and distributed systems, describes how queues act as intermediaries to decouple producers and consumers, outlines benefits such as faster response, reliability, and scalability, and details why a distributed architecture is needed for multi‑system collaboration and fault tolerance.

Backend Architecturedistributed systemsscalability
0 likes · 3 min read
Why Distributed Message Queues Are Essential for Scalable Systems
21CTO
21CTO
Feb 9, 2016 · Operations

Weibo’s Cross‑IDC Image Storage: Scaling Architecture & Real‑Time Compression

This article explains how Weibo’s massive image‑hosting platform uses a cross‑IDC distributed object storage system, optimized upload/download pipelines, and a custom compression library to handle billions of images and extreme traffic spikes during events like the Chinese New Year.

Backend ArchitectureImage storagecompression
0 likes · 8 min read
Weibo’s Cross‑IDC Image Storage: Scaling Architecture & Real‑Time Compression
21CTO
21CTO
Feb 6, 2016 · Backend Development

How LinkedIn Scaled to 300M Users: Lessons from a Decade of Backend Architecture

This article chronicles LinkedIn's evolution from a monolithic Leo application to a massive micro‑service ecosystem, detailing the introduction of member graphs, read‑only replicas, caching layers, Kafka pipelines, Rest.li APIs, super‑blocks, and multi‑data‑center strategies that enable handling billions of requests daily.

Backend ArchitectureKafkaLinkedIn
0 likes · 8 min read
How LinkedIn Scaled to 300M Users: Lessons from a Decade of Backend Architecture
21CTO
21CTO
Feb 4, 2016 · Backend Development

How Tumblr Scaled to 5 Billion Page Views: Inside Their Distributed Architecture

This article examines how Tumblr handled rapid growth—processing 5 billion daily page views, 40 k requests per second, and terabytes of data—by evolving from a LAMP stack to a Scala‑based, Finagle‑driven distributed system with HBase, Redis, Kafka, and a cell architecture that supports massive real‑time dashboards.

Backend ArchitectureFinagleRedis
0 likes · 21 min read
How Tumblr Scaled to 5 Billion Page Views: Inside Their Distributed Architecture
21CTO
21CTO
Jan 22, 2016 · Backend Development

Mastering Scale‑Up: How to Maximize Single‑Server Concurrency for Web Apps

This article explains why high‑concurrency design is essential for modern internet services, compares vertical (scale‑up) and horizontal (scale‑out) scaling, revisits the C10K/C10M challenges, and reviews process, thread, coroutine, and event‑driven models to help engineers build ultra‑scalable web servers.

Backend ArchitectureScale‑UpWeb Server
0 likes · 13 min read
Mastering Scale‑Up: How to Maximize Single‑Server Concurrency for Web Apps
21CTO
21CTO
Jan 18, 2016 · Backend Development

From MUD1 to Modern MMO: Evolution of Game Server Architectures

This article traces the development of game server architectures from early text‑based MUD systems through first‑generation HTTP‑based services for simple card and runner games, to the complex, distributed backend designs used by modern MMORPGs, highlighting key technologies, design choices, and scaling challenges.

Backend ArchitectureMMOMUD
0 likes · 11 min read
From MUD1 to Modern MMO: Evolution of Game Server Architectures
Qunar Tech Salon
Qunar Tech Salon
Jan 17, 2016 · Backend Development

Design and Technical Challenges of High‑Concurrency Flash Sale (Seckill) Systems

This article analyzes the characteristics and technical challenges of flash‑sale (seckill) systems, proposes isolation and static‑page strategies, outlines architecture principles, detailed front‑end and service‑layer designs, discusses database sharding, caching, concurrency control, overload protection, and anti‑cheat measures to ensure reliable high‑throughput order processing.

Backend ArchitectureFlash Salecaching
0 likes · 31 min read
Design and Technical Challenges of High‑Concurrency Flash Sale (Seckill) Systems
21CTO
21CTO
Jan 12, 2016 · Backend Development

Scalable Distributed Image Storage and Load Balancing for Web Sites

This article explains why serving many images strains web servers, outlines the challenges of I/O bottlenecks, and presents a practical, scalable solution that uses distributed image servers, dynamic load balancing, random selection algorithms, and health monitoring to improve performance for medium‑size business sites.

Backend ArchitectureLoad Balancingdistributed storage
0 likes · 9 min read
Scalable Distributed Image Storage and Load Balancing for Web Sites
Architect
Architect
Jan 11, 2016 · Backend Development

Understanding Redis’s Reactor Pattern and I/O Multiplexing

This article explains how Redis, a single‑process single‑threaded in‑memory database, uses the Reactor pattern and various I/O multiplexing techniques such as select, poll, epoll, and kqueue to efficiently handle thousands of concurrent client connections.

Backend ArchitectureI/O multiplexingReactor pattern
0 likes · 12 min read
Understanding Redis’s Reactor Pattern and I/O Multiplexing
21CTO
21CTO
Jan 10, 2016 · Backend Development

Designing a Scalable High‑Concurrency Distributed Backend for Millions of PV Sites

This article outlines a comprehensive design for a high‑concurrency distributed backend system that handles tens of millions of page views, detailing group‑based data partitioning, master‑slave roles, consistency models, heartbeat services, and global coordination to achieve scalability and fault tolerance.

Backend Architectureconsistencyhigh concurrency
0 likes · 19 min read
Designing a Scalable High‑Concurrency Distributed Backend for Millions of PV Sites
21CTO
21CTO
Jan 5, 2016 · Backend Development

Inside Xiaomi Push Service: Architecture, Performance, and Lessons Learned

The article details Xiaomi Push Service's XMPP‑based protocol, multi‑layer server architecture, client SDK design, scalability measures, security mechanisms, performance metrics during the 11.11 promotion, major refactorings, and practical insights for building high‑throughput push systems.

Backend ArchitectureThriftXMPP
0 likes · 9 min read
Inside Xiaomi Push Service: Architecture, Performance, and Lessons Learned
21CTO
21CTO
Dec 16, 2015 · Backend Development

Inside Sina Weibo’s Architecture: Scaling to Billions of Users

During a 2015 tech salon, Weibo platform architect Wei Xiangjun dissected the essence of system architecture, illustrating how Sina Weibo scales to billions of users through multi‑layered services, sharding, CDN, multi‑datacenter caching, orthogonal decomposition, and robust monitoring, offering practical insights for large‑scale backend design.

Backend Architecturecachingperformance optimization
0 likes · 22 min read
Inside Sina Weibo’s Architecture: Scaling to Billions of Users
21CTO
21CTO
Dec 11, 2015 · Backend Development

How 58.com Scaled from 10k to Over 1 Billion Visits: Lessons in Evolving Architecture

From a single‑machine “all‑in‑one” setup to a distributed, service‑oriented architecture, 58.com’s journey illustrates how startups can evolve their backend systems—adopting LAMP, read/write splitting, vertical splitting, caching, Java migration, and automated services—to handle traffic growth from tens of thousands to over a billion visits.

Backend Architectureperformance optimizationscalability
0 likes · 15 min read
How 58.com Scaled from 10k to Over 1 Billion Visits: Lessons in Evolving Architecture
21CTO
21CTO
Dec 11, 2015 · Backend Development

From Simple Polling to Scalable Microservices: JD’s Dongdong IM Evolution

This article chronicles the architectural journey of JD’s Dongdong instant‑messaging platform, detailing its early simple polling design, subsequent performance and scalability challenges, and the progressive shifts toward service‑oriented, micro‑service, and cloud‑native architectures that support massive user growth.

Backend ArchitectureIM SystemMicroservices
0 likes · 11 min read
From Simple Polling to Scalable Microservices: JD’s Dongdong IM Evolution
21CTO
21CTO
Nov 28, 2015 · Backend Development

How 58.com Scales 40 Billion Daily Requests: Inside Its IM and Mobile Architecture

This article examines 58.com’s BangBang system architecture, detailing its four‑layer backend design, evolution from a traditional IM to a mobile management platform, and the push technologies used to support massive O2O traffic and millions of concurrent users.

Backend ArchitectureO2Omobile integration
0 likes · 8 min read
How 58.com Scales 40 Billion Daily Requests: Inside Its IM and Mobile Architecture
21CTO
21CTO
Nov 25, 2015 · Backend Development

How Uber Scales Its Real‑Time Ride‑Sharing Platform: Architecture & Lessons

This article examines Uber's rapid 38‑fold growth and the engineering choices behind its real‑time market platform, detailing the scheduling system, geographic indexing, microservices, Ringpop, TChannel, and strategies for scalability, availability, and fault tolerance.

Backend ArchitectureMicroservicesUber
0 likes · 22 min read
How Uber Scales Its Real‑Time Ride‑Sharing Platform: Architecture & Lessons
21CTO
21CTO
Nov 18, 2015 · Backend Development

How Xiaomi Engineered a High‑Performance Flash‑Sale System for the 2014 Mi Fan Festival

This article details Xiaomi's step‑by‑step design and evolution of its flash‑sale platform, covering the initial PHP‑Redis solution, the challenges of extreme concurrency, and the later Go‑based architecture that enabled millions of users to purchase smartphones reliably during the 2014 Mi Fan Festival.

Backend ArchitectureFlash SaleGo
0 likes · 15 min read
How Xiaomi Engineered a High‑Performance Flash‑Sale System for the 2014 Mi Fan Festival
dbaplus Community
dbaplus Community
Nov 11, 2015 · Backend Development

Designing Scalable Flash‑Sale Architecture to Survive Traffic Surges

This article explains how to design a high‑availability flash‑sale system by separating business and data layers, using Redis queues for pressure isolation, ensuring inventory consistency, handling transaction reconciliation, and addressing anti‑fraud measures to cope with massive concurrent traffic.

Backend ArchitectureFlash SaleRedis
0 likes · 16 min read
Designing Scalable Flash‑Sale Architecture to Survive Traffic Surges
21CTO
21CTO
Nov 6, 2015 · Backend Development

How WeChat & Momo Scale IM: Lessons on Battery, Network, and Custom Protocols

This article analyzes the architectural choices behind WeChat and Momo instant‑messaging services, covering battery and traffic constraints, network reliability, the shift from XMPP to proprietary long/short connections, protocol design with protobuf, and operational strategies for scaling massive user bases.

Backend ArchitectureInstant MessagingProtobuf
0 likes · 12 min read
How WeChat & Momo Scale IM: Lessons on Battery, Network, and Custom Protocols
21CTO
21CTO
Nov 2, 2015 · Backend Development

How WeChat Scales: Backend Architecture for Ultra‑Low Latency Messaging

The article outlines WeChat’s backend design that achieves seamless, low‑latency messaging through a minimalist sync protocol, efficient notification mechanisms, a three‑tier RPC framework, user‑level thread concurrency, and globally distributed IDC architecture ensuring high availability and eventual consistency.

Backend ArchitectureRPCWeChat
0 likes · 7 min read
How WeChat Scales: Backend Architecture for Ultra‑Low Latency Messaging
21CTO
21CTO
Oct 29, 2015 · Backend Development

Scaling Sina's News Comment System: From 3.0 to 5.0 – Key Backend Lessons

This article chronicles the evolution of Sina's news comment platform from a single‑server C++/MySQL prototype to a multi‑node, asynchronous, Python‑based architecture, highlighting the caching, sharding, and queueing techniques that enabled the system to survive massive traffic spikes without downtime.

Backend ArchitectureMessage QueueScalable Systems
0 likes · 21 min read
Scaling Sina's News Comment System: From 3.0 to 5.0 – Key Backend Lessons
21CTO
21CTO
Oct 24, 2015 · Backend Development

How to Build Scalable, High‑Performance Large‑Scale Websites: Architecture Evolution

This article examines the core challenges of massive web platforms—huge user bases, high concurrency, and massive data—and walks through a step‑by‑step evolution of architecture from a single‑server setup to distributed caching, clustering, read/write separation, CDN, and micro‑service strategies for achieving high availability, performance, and security.

Backend Architecturecachingdistributed systems
0 likes · 10 min read
How to Build Scalable, High‑Performance Large‑Scale Websites: Architecture Evolution
21CTO
21CTO
Oct 1, 2015 · Backend Development

Inside WeChat Red Packets: User Motives, UI Flow, and Backend Architecture

This article dissects the entire WeChat red‑packet ecosystem, exploring why users send and grab packets, the entry points, detailed UI screens, database schema, random‑distribution algorithms, caching strategies, and the full front‑end/back‑end interaction sequence.

Backend ArchitectureDatabase DesignUI flow
0 likes · 25 min read
Inside WeChat Red Packets: User Motives, UI Flow, and Backend Architecture
21CTO
21CTO
Sep 21, 2015 · Backend Development

What Can Three Kingdoms Heroes Teach Us About Building a Robust Web Framework?

Drawing parallels between Three Kingdoms figures and web framework components, the article explains how each module—from the entry point to data and cache layers—functions, offering practical insights into designing clear, maintainable, and high‑performance backend architectures for modern web applications.

Backend ArchitectureModule DesignSoftware Engineering
0 likes · 9 min read
What Can Three Kingdoms Heroes Teach Us About Building a Robust Web Framework?
21CTO
21CTO
Sep 10, 2015 · Backend Development

Inside 58.com’s Mobile O2O Platform: Architecture, Evolution, and Push Tech

Sun Xuan, a system architect at 58.com, details the evolution of the company's merchant mobile management platform—from its early IM‑centric design through third‑party service integration to a lightweight client architecture—while also dissecting core O2O technologies such as long‑connection push, LBS, and cross‑platform notification strategies.

Backend ArchitectureIMScalable Systems
0 likes · 9 min read
Inside 58.com’s Mobile O2O Platform: Architecture, Evolution, and Push Tech
21CTO
21CTO
Aug 31, 2015 · Backend Development

Scaling JD.com’s Product Detail Pages with Dynamic, High‑Performance Architecture

This article details the evolution and redesign of JD.com’s product detail page architecture, describing the transition from static HTML generation to a dynamic, high‑performance, multi‑datacenter system built on key‑value storage, Nginx + Lua, asynchronous processing, multi‑level caching, and robust scaling and reliability strategies.

Backend ArchitectureHigh AvailabilityLua
0 likes · 34 min read
Scaling JD.com’s Product Detail Pages with Dynamic, High‑Performance Architecture
High Availability Architecture
High Availability Architecture
Aug 31, 2015 · Backend Development

High‑Availability Architecture for JD.com Product Detail Pages

This article describes how JD.com redesigned its product detail page system from a static, cache‑heavy architecture to a fully dynamic, multi‑level cached service using Nginx+Lua, JIMDB, and asynchronous workers, addressing scalability, performance, and high‑availability challenges for billions of daily page views.

Backend ArchitectureHigh AvailabilityJimdb
0 likes · 30 min read
High‑Availability Architecture for JD.com Product Detail Pages
21CTO
21CTO
Aug 18, 2015 · Cloud Computing

What I Learned Building a Hybrid Cloud System: Architecture, Tools, and Best Practices

Over the past two months I helped develop a distributed hybrid‑cloud platform, tackling challenges from OS differences and network ports to message queues, logging, multi‑language integration, and testing, and I share the architectural decisions, tooling choices, and practical lessons learned for building robust backend systems.

Backend Architecturedistributed systemshybrid cloud
0 likes · 12 min read
What I Learned Building a Hybrid Cloud System: Architecture, Tools, and Best Practices
21CTO
21CTO
Aug 15, 2015 · Backend Development

Inside Weibo’s Third‑Generation Backend Architecture: Scalability and High‑Availability

An in‑depth look at Weibo’s evolution to its third‑generation backend system, detailing the orthogonal decomposition model, three‑tier horizontal layering, key middleware such as MCQ, Motan RPC, SSDCache, and the WatchMan tracing platform that together enable high‑availability, massive concurrency, and low‑latency services for billions of users.

Backend ArchitectureHigh AvailabilityMiddleware
0 likes · 12 min read
Inside Weibo’s Third‑Generation Backend Architecture: Scalability and High‑Availability
Architect
Architect
Jul 22, 2015 · Backend Development

Using an API Gateway in a Microservices Architecture

The article explains how an API Gateway can consolidate multiple fine‑grained microservice endpoints into a single coarse‑grained API for mobile clients, discussing its design considerations, benefits, drawbacks, and implementation techniques such as reactive programming, service discovery, and fault tolerance.

API GatewayBackend ArchitectureFault Tolerance
0 likes · 13 min read
Using an API Gateway in a Microservices Architecture
Java High-Performance Architecture
Java High-Performance Architecture
Jul 20, 2015 · Backend Development

When to Use Session Sharing vs. Session Persistence in Load‑Balanced Backends

The article explains why session sharing across servers solves independent session issues but is unsuitable for tightly coupled multi‑step interactions or frameworks with special session handling, and introduces session persistence (sticky sessions) such as Nginx's ip_hash to keep a user bound to a single backend server.

Backend ArchitectureLoad Balancingsession persistence
0 likes · 3 min read
When to Use Session Sharing vs. Session Persistence in Load‑Balanced Backends
Architect
Architect
Jul 20, 2015 · Backend Development

Weibo Image Storage Architecture and High‑Performance Image Processing Pipeline

The article describes Weibo's large‑scale cross‑IDC distributed image storage system, its upload and download workflows, the challenges of massive seasonal traffic spikes, and the custom pipeline and lightweight compression library designed to achieve strong consistency and low‑latency image delivery.

Backend ArchitectureImage storageWeibo
0 likes · 8 min read
Weibo Image Storage Architecture and High‑Performance Image Processing Pipeline
High Availability Architecture
High Availability Architecture
May 21, 2015 · Backend Development

Understanding Instant Messaging (IM) Architecture, Protocol Design, and Real‑Time Web Chat Implementation

This article explains the fundamentals of instant messaging, its system characteristics, protocol layers (application, security, transport), practical protocol examples, and a detailed real‑time web chatroom design using HTTP long‑polling and backend architecture considerations.

Backend ArchitectureInstant MessagingReal‑time communication
0 likes · 20 min read
Understanding Instant Messaging (IM) Architecture, Protocol Design, and Real‑Time Web Chat Implementation
Art of Distributed System Architecture Design
Art of Distributed System Architecture Design
Feb 27, 2015 · Backend Development

How WeChat Processed Over 1 Billion Red Packets: Backend Architecture and High‑Concurrency Strategies

The article explains how WeChat’s backend handled the massive surge of red‑packet traffic during the 2015 New Year by employing loss‑tolerant services, flexible availability, modular design, asynchronous processing, and overload protection to ensure fast, accurate, and stable user experiences.

Backend ArchitectureLossy ServiceWeChat
0 likes · 9 min read
How WeChat Processed Over 1 Billion Red Packets: Backend Architecture and High‑Concurrency Strategies
Nightwalker Tech
Nightwalker Tech
Jan 4, 2015 · Backend Development

Design and Pitfalls of Internet App Long‑Connection Push Systems and Related Backend Practices

This article surveys the architecture of long‑connection push systems for internet apps, distinguishes connection types, outlines client and server handling strategies, reviews mainstream backend solutions, and shares practical insights on security, API design, operations, queue services, debugging, and NoSQL usage.

Backend ArchitectureDebuggingMessage Queue
0 likes · 32 min read
Design and Pitfalls of Internet App Long‑Connection Push Systems and Related Backend Practices
Ctrip Technology
Ctrip Technology
Oct 15, 2014 · Backend Development

Why Read/Write Separation Belongs in the Service Layer, Not Just the Database

The article explains that database read/write separation offers limited performance gains and mainly serves data safety, while true scalability for read operations comes from caching and server clusters, and that write operations require a single dedicated server and actor‑model programming for safe concurrency.

Backend ArchitectureRead-Write Separationactor-model
0 likes · 6 min read
Why Read/Write Separation Belongs in the Service Layer, Not Just the Database
Baidu Tech Salon
Baidu Tech Salon
Jun 9, 2014 · Game Development

Build vs Buy: Key Considerations for Mobile Game Backend Development

When deciding whether to build or buy a mobile game backend, evaluate the backend’s impact on gameplay, your team’s expertise and resource availability, the long‑term maintenance and update commitments, risk tolerance, and budget constraints to choose the most scalable, cost‑effective solution.

Backend ArchitectureGame Backendbackend provider
0 likes · 9 min read
Build vs Buy: Key Considerations for Mobile Game Backend Development
Baidu Tech Salon
Baidu Tech Salon
Apr 30, 2014 · Backend Development

Logical Coupling, Service Layer Design, and Distributed System Architecture for Large-Scale Web Applications

The article examines the inevitability of service coupling in large‑scale web applications and proposes a two‑dimensional architecture that separates business and logic layers, uses internal data stores, introduces a naming‑and‑location service, selects appropriate transport and RPC protocols, and automates operations with health checks, load balancing, and failover to achieve continuous reliability.

Backend ArchitectureNaming ServiceOperations
0 likes · 29 min read
Logical Coupling, Service Layer Design, and Distributed System Architecture for Large-Scale Web Applications