BestHub
Sign in
Tagged articles
45 articles
Page 1 of 1
Alibaba Cloud Native
Alibaba Cloud Native
Mar 20, 2026 · Cloud Native

How a Gaming Platform Scaled to Millions with RocketMQ & Kafka: A Cloud‑Native Success Story

Facing explosive growth, the game‑service platform 悠悠有品 rebuilt its architecture on Alibaba Cloud, using RocketMQ for core transaction messaging and Kafka for data synchronization, achieving elastic scaling, high availability, cost reduction, and reliable high‑concurrency processing across its trading and analytics pipelines.

KafkaMessagingRocketMQ
0 likes · 8 min read
How a Gaming Platform Scaled to Millions with RocketMQ & Kafka: A Cloud‑Native Success Story
Efficient Ops
Efficient Ops
Feb 11, 2026 · Databases

How Merged Seckill Boosts MySQL Write Throughput by 5× for High‑Concurrency Flash Sales

The article explains a MySQL kernel‑level merged seckill optimization that replaces traditional queue‑based flash‑sale handling, achieving up to 5‑fold throughput gains (up to 1.5 W/s) without requiring SQL changes, detailing background, performance results, bottleneck analysis, design of cache visibility, leader‑follower coordination, row‑lock refinements, binlog parallelism, and crash‑recovery considerations.

Seckilldatabase-optimizationhigh-concurrency
0 likes · 12 min read
How Merged Seckill Boosts MySQL Write Throughput by 5× for High‑Concurrency Flash Sales
Ray's Galactic Tech
Ray's Galactic Tech
Jan 16, 2026 · Backend Development

How to Build a 100k+ TPS Flash‑Sale System with 7 Layered Defense Strategies

This article presents a step‑by‑step architecture for a high‑traffic flash‑sale system that filters 99.9% of requests before the database, using layered front‑end, gateway, cache, message‑queue, and stateless scaling techniques to achieve over 100,000 TPS with strong consistency and availability.

Circuit Breakingbackend-architectureflash sale
0 likes · 10 min read
How to Build a 100k+ TPS Flash‑Sale System with 7 Layered Defense Strategies
Tech Freedom Circle
Tech Freedom Circle
Oct 12, 2025 · Backend Development

Understanding and Solving GC Spikes in High‑Throughput Java Services

The article explains what a GC spike (Garbage Collection Spike) is, analyzes its typical causes such as large short‑lived objects, memory leaks, and heap configuration, presents a real‑world high‑concurrency case study, and details step‑by‑step JVM tuning and architectural strategies that reduced latency spikes and raised service availability from 95% to over 99.99%.

g1gcgchigh-concurrency
0 likes · 32 min read
Understanding and Solving GC Spikes in High‑Throughput Java Services
MaGe Linux Operations
MaGe Linux Operations
Aug 29, 2025 · Operations

How to Supercharge Nginx for Millions of QPS: A Complete Guide

Discover proven strategies to optimize Nginx under extreme traffic, covering benchmark testing, kernel tuning, configuration tweaks, caching, load balancing, SSL hardening, monitoring, and real-world case studies that demonstrate how to achieve stable high‑QPS performance while minimizing latency and resource usage.

high-concurrencyload-balancingmonitoring
0 likes · 22 min read
How to Supercharge Nginx for Millions of QPS: A Complete Guide
Zhuanzhuan Tech
Zhuanzhuan Tech
Jul 31, 2025 · Backend Development

Designing a Billion‑Scale Open Platform: Architecture & Performance

This article outlines a comprehensive engineering roadmap for constructing a high‑performance, highly available open platform capable of handling billions of daily API calls, covering three‑layer architecture, multi‑level caching, asynchronous messaging, database sharding, distributed transactions, and progressive scaling strategies.

MicroservicesOpen Platformdistributed architecture
0 likes · 18 min read
Designing a Billion‑Scale Open Platform: Architecture & Performance
Mike Chen's Internet Architecture
Mike Chen's Internet Architecture
Jun 4, 2025 · Backend Development

Understanding Spring Cloud Gateway’s Non‑Blocking Architecture for Million‑Level Concurrency

The article explains how Spring Cloud Gateway leverages a fully non‑blocking, reactive architecture built on Project Reactor and Netty to handle millions of concurrent requests, and discusses essential protection mechanisms such as rate limiting, circuit breaking, and degradation for high‑traffic scenarios.

Circuit BreakingNon-blockingSpring Cloud Gateway
0 likes · 6 min read
Understanding Spring Cloud Gateway’s Non‑Blocking Architecture for Million‑Level Concurrency
Senior Tony
Senior Tony
Jun 3, 2025 · Backend Development

How to Build a High‑Performance Short URL Service: Redirects, Generation Strategies, and Scaling

This article explains the core functions of a short‑URL system, compares permanent (301) and temporary (302) redirects, details four generation methods—including hash, auto‑increment, random strings, and pre‑generation—and outlines a high‑concurrency architecture with sharding, caching, and Snowflake IDs.

System Designhigh-concurrencyshorturl
0 likes · 9 min read
How to Build a High‑Performance Short URL Service: Redirects, Generation Strategies, and Scaling
Java Tech Enthusiast
Java Tech Enthusiast
May 31, 2025 · Fundamentals

Why Threads Alone Struggle to Achieve Million‑Scale Concurrency and How Coroutines Provide a Better Solution

The article examines why relying solely on threads cannot achieve single‑machine million‑level concurrency, analyzing thread resource consumption, context‑switch overhead, and contrasting it with user‑space coroutine scheduling that offers predictable, low‑cost switches, making coroutines better suited for IO‑intensive high‑concurrency scenarios.

CoroutinesSchedulingThreads
0 likes · 6 min read
Why Threads Alone Struggle to Achieve Million‑Scale Concurrency and How Coroutines Provide a Better Solution
DaTaobao Tech
DaTaobao Tech
Apr 28, 2025 · Frontend Development

Front‑End Architecture and Performance Optimization for a Large‑Scale Chinese New Year Interactive Activity

The article details a large‑scale Chinese New Year interactive activity’s front‑end architecture, describing a layered system for business logic, data abstraction, and animation engines, unified data handling, dynamic animation rendering with downgrade paths, high‑concurrency QPS reduction, resilience measures, and extensive performance and workflow optimizations.

Data ManagementResilienceanimation
0 likes · 15 min read
Front‑End Architecture and Performance Optimization for a Large‑Scale Chinese New Year Interactive Activity
Ma Wei Says
Ma Wei Says
Apr 23, 2025 · Backend Development

Mastering Redis Counters: INCR/INCRBY vs DECR/DECRBY and Robust Design Patterns

This article explains Redis's atomic counter commands (INCR, INCRBY, DECR, DECRBY), highlights their pitfalls such as missing TTL and concurrency issues, and presents practical design solutions—including SET NX+EX initialization, double‑TTL compensation, retry queues, fallback strategies, and performance optimizations like Lua scripting and pipelining.)

CounterTTLdecr
0 likes · 10 min read
Mastering Redis Counters: INCR/INCRBY vs DECR/DECRBY and Robust Design Patterns
Tencent Cloud Developer
Tencent Cloud Developer
Oct 18, 2024 · Backend Development

Tencent Meeting "My Recordings" List Optimization Practice

Tencent Meeting optimized its “My Recordings” list by replacing offset pagination with cursor‑based seeks, implementing a two‑layer cache separating ID lists from record details, choosing MongoDB for multi‑source aggregation, and adding reliable Kafka‑driven sync, cutting latency from 308 ms to 70 ms while supporting over 700 QPS.

BackendMongoDBcaching
0 likes · 36 min read
Tencent Meeting "My Recordings" List Optimization Practice
Wukong Talks Architecture
Wukong Talks Architecture
Jul 8, 2024 · Backend Development

Design and Evolution of Ctrip Ticket Booking System for Flash‑Sale Events

This article analyzes the challenges faced by Ctrip's ticket‑booking transaction system during high‑traffic flash‑sale events and presents a series of architectural optimizations—including Redis caching, database load mitigation, supplier‑system safeguards, and fine‑grained traffic‑control strategies—to achieve stable, consistent, and fast performance under extreme concurrency.

BackendDatabase OptimizationSystem Architecture
0 likes · 15 min read
Design and Evolution of Ctrip Ticket Booking System for Flash‑Sale Events
Selected Java Interview Questions
Selected Java Interview Questions
Mar 22, 2024 · Backend Development

Design and Performance Optimization of a High‑Concurrency Volunteer Registration System

This article recounts the end‑to‑end design, testing, and iterative optimization of a volunteer registration platform that required tens of thousands of QPS, covering requirement analysis, middleware benchmarking, data partitioning, compression, connection‑limit handling, and final deployment lessons.

RocketMQhigh-concurrencyperformance-testing
0 likes · 16 min read
Design and Performance Optimization of a High‑Concurrency Volunteer Registration System
MaGe Linux Operations
MaGe Linux Operations
Aug 25, 2023 · Backend Development

How to Build a Million‑User Ticket Spike System with Load Balancing, Redis, and Go

This article explores the architecture and implementation of a high‑concurrency ticket‑spike system, detailing load‑balancing strategies, in‑memory stock deduction, Redis atomic operations, and Go code examples that enable millions of users to purchase tickets simultaneously without overselling or underselling.

distributed-systemshigh-concurrencyload-balancing
0 likes · 19 min read
How to Build a Million‑User Ticket Spike System with Load Balancing, Redis, and Go
Rare Earth Juejin Tech Community
Rare Earth Juejin Tech Community
Aug 4, 2023 · Backend Development

Designing a High-Concurrency Flash Sale System: Architecture, Rate Limiting, Caching, and Monitoring

This article outlines the end‑to‑end design of a high‑availability flash‑sale system, covering traffic spikes, overload protection, inventory consistency, multi‑level caching, token‑bucket rate limiting, distributed queue processing, service monitoring, and stress‑testing strategies to ensure reliable million‑level transaction handling.

cachingdistributed-systemshigh-concurrency
0 likes · 15 min read
Designing a High-Concurrency Flash Sale System: Architecture, Rate Limiting, Caching, and Monitoring
21CTO
21CTO
Mar 24, 2023 · Backend Development

How to Build a High‑Concurrency Ticket‑Spiking System Like 12306 with Go and Redis

This article dissects the architecture of a 12306‑style ticket‑spiking service, explaining load‑balancing strategies, weighted Nginx routing, local and remote stock deduction using Go and Redis, and demonstrates performance testing that achieves thousands of requests per second while preventing oversell and undersell.

BackendGohigh-concurrency
0 likes · 20 min read
How to Build a High‑Concurrency Ticket‑Spiking System Like 12306 with Go and Redis
High Availability Architecture
High Availability Architecture
Jan 9, 2023 · Frontend Development

Low‑Code Platform Practices at vivo: Frontend‑Backend Separation, High‑Performance Rendering Engine, and Efficient Visual Configuration

This article details vivo's low‑code platform experience, covering a front‑end/back‑end separated low‑code solution, a self‑built high‑performance rendering engine, efficient visual configuration methods, billion‑scale content delivery, and how low‑code coexists with traditional development to boost productivity and scalability.

BackendRendering Enginehigh-concurrency
0 likes · 16 min read
Low‑Code Platform Practices at vivo: Frontend‑Backend Separation, High‑Performance Rendering Engine, and Efficient Visual Configuration
IT Architects Alliance
IT Architects Alliance
Sep 8, 2022 · Backend Development

Design and Implementation of a High‑QPS Spring Festival Red Envelope System Simulating 10 Billion Requests

This article describes the design, hardware and software setup, implementation, testing phases, and performance analysis of a Go‑based backend system that simulates a Spring Festival red‑envelope service capable of handling up to 10 billion requests with peak loads of 60 k QPS per server.

BackendGolangPerformance Testing
0 likes · 19 min read
Design and Implementation of a High‑QPS Spring Festival Red Envelope System Simulating 10 Billion Requests
php Courses
php Courses
May 13, 2022 · Backend Development

Designing a High-Concurrency Ticketing System with Load Balancing, Redis, and Go

This article explores the architecture and implementation of a high‑concurrency train ticket flash‑sale system, detailing load‑balancing strategies, Nginx weighted round‑robin, Redis‑based inventory management, and Go code examples that demonstrate local and remote stock deduction, performance testing, and fault‑tolerant design.

BackendGohigh-concurrency
0 likes · 20 min read
Designing a High-Concurrency Ticketing System with Load Balancing, Redis, and Go
Top Architect
Top Architect
Feb 25, 2022 · Backend Development

Meituan Instant Logistics: Evolution of Distributed System Architecture and Practices

The article details Meituan's five‑year journey in instant logistics, describing the evolution from early vertical services to micro‑service and cloud‑native architectures, the technical challenges of massive order‑rider matching, high availability, AI‑driven optimization, and the operational practices adopted to ensure scalability and reliability.

AILogisticsdistributed-systems
0 likes · 10 min read
Meituan Instant Logistics: Evolution of Distributed System Architecture and Practices
Code Ape Tech Column
Code Ape Tech Column
Feb 21, 2022 · Backend Development

Cache Consistency Issues and Solutions: Cache‑Aside Pattern, Lazy Deletion, and High‑Concurrency Queue Design

This article explains the fundamental cache‑aside pattern, why lazy cache deletion is preferred over immediate updates, analyzes simple and complex cache‑database inconsistency scenarios, and proposes a high‑concurrency queue‑based solution with practical considerations for backend systems.

ConsistencyLazy Deletioncache-aside
0 likes · 11 min read
Cache Consistency Issues and Solutions: Cache‑Aside Pattern, Lazy Deletion, and High‑Concurrency Queue Design
Java Interview Crash Guide
Java Interview Crash Guide
Jan 25, 2022 · Backend Development

How to Simulate 10 Billion WeChat Red‑Packet Requests on a Single Server

This article explains how the author designed and implemented a Go‑based backend that can simulate up to 100 million concurrent users and process billions of red‑packet requests, detailing the hardware setup, performance goals, load‑balancing techniques, monitoring, and the results of multi‑stage stress tests.

Golanghigh-concurrencyred packet
0 likes · 17 min read
How to Simulate 10 Billion WeChat Red‑Packet Requests on a Single Server
JavaEdge
JavaEdge
Dec 20, 2021 · Big Data

How Kafka Broker Handles High‑Throughput Requests: Deep Dive into Its Network Architecture

This article provides a comprehensive analysis of Kafka Broker's network and request‑handling architecture, tracing its evolution from a simple sequential model through multithreaded and event‑driven designs to a Reactor‑based NIO implementation, and offers concrete tuning recommendations for high‑concurrency deployments.

Reactor Patternhigh-concurrencyjava-nio
0 likes · 22 min read
How Kafka Broker Handles High‑Throughput Requests: Deep Dive into Its Network Architecture
Top Architect
Top Architect
Mar 26, 2021 · Backend Development

High-Concurrency Ticket Booking System: Architecture, Load Balancing, and Go Implementation

This article explores the design and implementation of a high‑concurrency train ticket spike system, detailing load‑balancing strategies with Nginx, distributed inventory management using Redis, Go‑based services, and performance testing, while addressing challenges such as overselling, fault tolerance, and efficient resource utilization.

GoNginxhigh-concurrency
0 likes · 19 min read
High-Concurrency Ticket Booking System: Architecture, Load Balancing, and Go Implementation
Volcano Engine Developer Services
Volcano Engine Developer Services
Mar 18, 2021 · Cloud Native

ByteDance’s Cloud‑Native Tricks for 703 Billion Festival Red‑Envelope Clicks

In 2021, ByteDance leveraged its cloud‑native stack—including traffic governance, service mesh, and rapid deployment pipelines—to deliver 703 billion red‑envelope interactions during the Spring Festival Gala, overcoming a 27‑day preparation window, high‑concurrency demands, and extensive emergency rehearsals to ensure seamless user experience.

cloud-nativehigh-concurrencyservice-mesh
0 likes · 16 min read
ByteDance’s Cloud‑Native Tricks for 703 Billion Festival Red‑Envelope Clicks
Top Architect
Top Architect
Dec 11, 2020 · Backend Development

Designing a High-Concurrency Ticket‑Spiking System with Load Balancing, Redis, and Go

This article explains how to build a high‑concurrency ticket‑spike system by analyzing 12306's extreme load, introducing multi‑layer load balancing (OSPF, LVS, Nginx), comparing stock‑deduction strategies, and presenting a Go prototype that uses in‑memory stock, Redis centralized inventory, and weighted Nginx routing to achieve scalable, fault‑tolerant performance.

GoNginxhigh-concurrency
0 likes · 19 min read
Designing a High-Concurrency Ticket‑Spiking System with Load Balancing, Redis, and Go
Architecture Digest
Architecture Digest
Aug 24, 2020 · Backend Development

Cache Consistency Strategies: Cache Aside Pattern, Deleting vs Updating Cache, and Queue‑Based Solutions for High Concurrency

This article explains the cache‑aside pattern, why deleting cache entries is often preferable to updating them, outlines basic and complex cache‑database inconsistency scenarios, and presents a queue‑driven approach with practical considerations for maintaining data consistency in high‑concurrency backend systems.

CacheConsistencyQueue
0 likes · 10 min read
Cache Consistency Strategies: Cache Aside Pattern, Deleting vs Updating Cache, and Queue‑Based Solutions for High Concurrency
Java Architect Essentials
Java Architect Essentials
Aug 13, 2020 · Backend Development

Design and Implementation of a High‑Throughput WeChat Red Packet System

This article describes the design, implementation, and performance testing of a simulated WeChat red‑packet service capable of handling up to 100 billion requests, detailing target load calculations, hardware and software choices, concurrency strategies in Go, monitoring tools, and experimental results across multiple QPS levels.

GolangLoad Testingbackend-architecture
0 likes · 18 min read
Design and Implementation of a High‑Throughput WeChat Red Packet System
Programmer DD
Programmer DD
May 17, 2020 · Backend Development

How to Build a High‑Performance Flash‑Sale System: Architecture, Bottlenecks, and Solutions

This article explains the key challenges of flash‑sale systems—overselling, massive concurrency, URL exposure, and database pressure—and presents a complete backend design with isolated databases, Redis clustering, dynamic URLs, rate‑limiting, asynchronous order processing, and service degradation strategies.

flash salehigh-concurrencyrate-limiting
0 likes · 15 min read
How to Build a High‑Performance Flash‑Sale System: Architecture, Bottlenecks, and Solutions
21CTO
21CTO
Mar 6, 2020 · Backend Development

How to Simulate 100 Billion WeChat Red Packet Requests on a Single Server

This article details a backend engineering practice that simulates 100 billion shake‑red‑packet requests by building a single‑machine prototype supporting one million connections, achieving peak QPS of 60 k, and demonstrates the methodology, hardware setup, code design, monitoring, and performance analysis.

BackendGolangLoad Testing
0 likes · 18 min read
How to Simulate 100 Billion WeChat Red Packet Requests on a Single Server
MaGe Linux Operations
MaGe Linux Operations
Jan 8, 2020 · Backend Development

Can Python Handle Millions of Requests per Second? Inside Japronto’s High‑Performance Microframework

This article explores how recent Python performance improvements and the ultra‑fast Japronto microframework enable handling over a million HTTP requests per second, detailing benchmark results, HTTP pipelining optimizations, C extensions, memory management tricks, and the underlying technologies that make such throughput possible.

AsyncBenchmarkingHTTP
0 likes · 9 min read
Can Python Handle Millions of Requests per Second? Inside Japronto’s High‑Performance Microframework
21CTO
21CTO
Nov 26, 2019 · Backend Development

How to Build a Million‑User Ticket Spike System with Load Balancing, Redis, and Go

This article explores the design of a high‑concurrency ticket‑spike system that can handle millions of simultaneous requests by combining multi‑layer load balancing, Nginx weighted round‑robin, Redis for atomic stock control, and Go‑based services, complete with code samples and performance testing.

distributed systemhigh-concurrencyload-balancing
0 likes · 20 min read
How to Build a Million‑User Ticket Spike System with Load Balancing, Redis, and Go
Big Data Technology & Architecture
Big Data Technology & Architecture
Nov 4, 2019 · Backend Development

Designing a High-Concurrency Ticket Spike System with Go, Nginx, and Redis

This article explains how to build a high‑concurrency ticket‑seckill system using Go, Nginx weighted load balancing, and Redis, covering architecture design, local and remote stock deduction, Lua scripting for atomic operations, and performance testing with ApacheBench to achieve thousands of requests per second without overselling.

GoNginxdistributed-systems
0 likes · 19 min read
Designing a High-Concurrency Ticket Spike System with Go, Nginx, and Redis
Architect's Tech Stack
Architect's Tech Stack
Aug 27, 2019 · Backend Development

Cache Consistency Issues and Solutions: Cache‑Aside Pattern, Lazy Deletion, and Queue‑Based Synchronization

The article explains how distributed cache consistency problems arise with read‑write operations, introduces the Cache‑Aside pattern and lazy‑deletion strategy, analyzes simple and complex inconsistency scenarios, and proposes a queue‑driven, serial processing solution with practical considerations for high‑concurrency backend systems.

BackendQueuecache-aside
0 likes · 11 min read
Cache Consistency Issues and Solutions: Cache‑Aside Pattern, Lazy Deletion, and Queue‑Based Synchronization
ITFLY8 Architecture Home
ITFLY8 Architecture Home
Jun 17, 2018 · Backend Development

How WeChat Scaled Red Packets for Billions of Transactions: Architecture & Strategies

This article explains how WeChat redesigned its red‑packet system for the 2016 Chinese New Year, detailing the dual‑data‑center architecture, order and user data separation, caching layers, traffic routing, high‑concurrency controls, database sharding, and graceful degradation to handle tens of billions of requests per minute.

BackendScalabilityWeChat
0 likes · 13 min read
How WeChat Scaled Red Packets for Billions of Transactions: Architecture & Strategies
Ctrip Technology
Ctrip Technology
Nov 16, 2017 · Backend Development

Design and Implementation of a Distributed Unique ID Generator for Ctrip User Accounts

This article describes Ctrip's design of a distributed, globally unique user ID generator for MySQL migration, covering requirements, evaluation of common approaches such as auto‑increment, UUID, Snowflake and Redis, and detailing the final Flicker‑based solution with segment caching using AtomicLong to achieve high concurrency and reliability.

BackendUnique IDdistributed-systems
0 likes · 9 min read
Design and Implementation of a Distributed Unique ID Generator for Ctrip User Accounts
Alibaba Cloud Developer
Alibaba Cloud Developer
Jan 22, 2017 · Backend Development

How Alibaba Scaled Double 11: Backend Strategies for Billions of Transactions

Alibaba's Double 11 festival broke sales records with 120.7 billion RMB, and the article details the backend engineering challenges and solutions—such as database sharding, SQL optimization, multi‑level caching, and modular architecture—that enabled the platform to handle millions of orders per second while preserving data consistency and performance.

Backendcachingdatabase
0 likes · 20 min read
How Alibaba Scaled Double 11: Backend Strategies for Billions of Transactions
ITFLY8 Architecture Home
ITFLY8 Architecture Home
Dec 12, 2016 · Backend Development

Designing a Scalable Insurance O2O Platform: Architecture, Services, and Data Strategies

This article explores how to build a high‑traffic insurance O2O platform for tens of millions of users by emphasizing simple micro‑service architecture, detailed functional requirements, performance targets, distributed storage, caching, service registration, and a practical technology stack for reliable, extensible backend development.

InsuranceMicroservicesarchitecture
0 likes · 19 min read
Designing a Scalable Insurance O2O Platform: Architecture, Services, and Data Strategies
WeChat Backend Team
WeChat Backend Team
Dec 4, 2016 · Backend Development

How We Scaled a New Year Gala Shake‑to‑Win System to 10 Million Requests per Second

This article revisits the technical design and evolution of the 2015 Chinese New Year Gala "shake" activity, detailing how the backend architecture was progressively refined—from a simple prototype to a production‑grade system capable of handling tens of millions of concurrent requests—through resource pre‑download, access‑layer integration, load‑balancing, and robust fail‑over mechanisms.

Load Testingdistributed-systemshigh-concurrency
0 likes · 21 min read
How We Scaled a New Year Gala Shake‑to‑Win System to 10 Million Requests per Second
Efficient Ops
Efficient Ops
Nov 1, 2015 · Operations

Building a High‑Performance Golang Server‑Client Monitoring System

This article explains how to design and implement an efficient Golang‑based server‑client monitoring solution called OWL, covering data packet structures, network protocols, client and server architecture, concurrency handling with goroutines, and practical code examples for high‑throughput operations.

GolangServer-Clienthigh-concurrency
0 likes · 12 min read
Building a High‑Performance Golang Server‑Client Monitoring System