Skip to content
Tagged articles

high concurrency

500 articles · Page 1 of 5
Mike Chen's Internet Architecture
Mike Chen's Internet Architecture
Nov 19, 2026 · Backend Development

Load Balancing Architecture Patterns: Layer 4, Layer 7, and Hybrid Compared

This article explains three load balancing architecture patterns—Layer 4 (transport-layer), Layer 7 (application-layer), and hybrid—comparing their mechanisms, performance trade-offs, typical implementations like LVS and Nginx, and how to combine them for high-concurrency, flexible routing in large-scale systems.

LVSNginxarchitecture patterns
0 likes · 5 min read
Load Balancing Architecture Patterns: Layer 4, Layer 7, and Hybrid Compared
Architect's Guide
Architect's Guide
Nov 18, 2026 · Backend Development

E-Commerce Inventory Deduction: From MySQL Row Locks to Redis Lua Scripts

This article analyzes three approaches to e-commerce inventory deduction—single-row MySQL, sharded MySQL, and Redis with Lua scripts—detailing why database row locks fail under high concurrency and providing a complete Redis-based implementation with distributed locking for cache initialization and atomic stock decrement.

Redisdistributed-locke-commerce
0 likes · 12 min read
E-Commerce Inventory Deduction: From MySQL Row Locks to Redis Lua Scripts
Xiaolin Talks Programming
Xiaolin Talks Programming
Nov 9, 2026 · Backend Development

Building a Production-Ready Online Exam System with Spring Boot 3: Paper Assembly, Anti-Cheating & Auto-Grading

This article details a production-grade Spring Boot 3 online exam system covering domain modeling, constraint-based paper assembly algorithms, anti-cheating measures with behavior logging and risk scoring, auto-grading strategies for objective and subjective questions, high-concurrency handling for exam start/submit, and score analysis with streaming exports.

Anti-CheatingAuto-GradingOnline Exam System
0 likes · 37 min read
Building a Production-Ready Online Exam System with Spring Boot 3: Paper Assembly, Anti-Cheating & Auto-Grading
Xiaolin Talks Programming
Xiaolin Talks Programming
Nov 8, 2026 · Backend Development

Building a Robust Member Points System with Spring Boot: Account Model, Idempotency & Reconciliation

This article details a production-grade member points and growth system built on Spring Boot, covering account modeling with ledger tables, batch-based expiration, FIFO deduction, idempotency keys, freeze/unfreeze flows, high-concurrency Redis pre-deduction with async DB persistence, anti-fraud layers, and a three-equation reconciliation framework with automated repair.

Anti-FraudDistributed SystemsIdempotency
0 likes · 34 min read
Building a Robust Member Points System with Spring Boot: Account Model, Idempotency & Reconciliation
Code Farming
Code Farming
Oct 29, 2026 · Backend Development

Why Financial Microservices Collapse During Big Promotions: A 5-Step Governance Blueprint

This article breaks down financial-grade microservices governance into five steps: identifying five core pain points, selecting the right service-oriented architecture evolution path, building a service registry with Nacos, implementing traffic control via rate limiting, circuit breaking, and degradation using Sentinel, and applying four fault-tolerance strategies plus canary releases to ensure stability during high-concurrency events.

Circuit BreakingFault ToleranceNacos
0 likes · 7 min read
Why Financial Microservices Collapse During Big Promotions: A 5-Step Governance Blueprint
Rain's Path to Java Mastery
Rain's Path to Java Mastery
Oct 22, 2026 · Databases

MySQL High-Concurrency Optimization: From Diagnosis to Sharding with Seckill Case Study

A layered MySQL optimization guide for high-concurrency scenarios covering bottleneck diagnosis, SQL/index tuning, transaction/lock optimization, a three-layer seckill inventory implementation (Redis Lua, MQ async, sharded buckets), caching patterns, read-write separation, connection pooling, InnoDB tuning, and sharding trade-offs, with real production metrics showing P99 latency dropping from 1.2s to 85ms.

Connection PoolInnoDBPerformance Optimization
0 likes · 64 min read
MySQL High-Concurrency Optimization: From Diagnosis to Sharding with Seckill Case Study
ITPUB
ITPUB
Oct 20, 2026 · Backend Development

Why WebSocket Broadcast Fails at 1M Viewers: Solving Massive Fan-Out in Live Chat

This article analyzes why naive WebSocket broadcast fails for million-viewer live chat due to bandwidth and client rendering limits, then presents a three-layer architecture with local fan-out, 100ms batching windows, priority-based sampling, and segmented sequence generation to reduce remote pushes from millions to dozens while maintaining perceived real-time experience.

Fan-outMessage BroadcastingNetty
0 likes · 21 min read
Why WebSocket Broadcast Fails at 1M Viewers: Solving Massive Fan-Out in Live Chat
Machine Learning Algorithms & Natural Language Processing
Machine Learning Algorithms & Natural Language Processing
Oct 19, 2026 · Artificial Intelligence

AdaFlash: Adaptive Speculative Decoding with Online Self-Improvement for High-Concurrency LLM Inference

Nanjing University and Huawei's Foundation Model team introduce AdaFlash, an adaptive speculative decoding framework that enables diffusion draft models to self-improve online via on-policy distillation and dynamic verification length prediction, achieving up to 5.32x end-to-end speedup on Qwen3-8B and 66% higher throughput under high concurrency.

AdaFlashLLM inference accelerationOn-Policy Distillation
0 likes · 17 min read
AdaFlash: Adaptive Speculative Decoding with Online Self-Improvement for High-Concurrency LLM Inference
Cilantro Loves Linux
Cilantro Loves Linux
Oct 9, 2026 · Backend Development

Four Principles of Large-Scale Internet Architecture: Availability, Scalability, Concurrency & Security Trade-offs

This chapter from "Architecture Fundamentals" defines four quality attributes — high availability, high scalability, high concurrency, and security — as the pillars of large-scale internet architecture, emphasizing that normal traffic tests only prove functional correctness, not resilience. It details the trade-offs between these attributes, concrete implementation patterns for each, and a practical checklist for deriving architecture from measurable business goals rather than stacking technologies.

Architecture PrinciplesDistributed SystemsHigh Availability
0 likes · 10 min read
Four Principles of Large-Scale Internet Architecture: Availability, Scalability, Concurrency & Security Trade-offs
Code Farmer Manor Chronicle
Code Farmer Manor Chronicle
Oct 7, 2026 · Backend Development

Mastering High-Concurrency Caching: Penetration, Breakdown, Avalanche & Hot Keys

This article explains four classic high-concurrency caching problems—cache penetration, breakdown, avalanche, and hot keys—their root causes, differences, and practical solutions including empty-value caching, Bloom filters, mutex locks, logical expiration, TTL jitter, multi-level caching, and cache-database consistency patterns.

Bloom filterCache AsideConsistency
0 likes · 12 min read
Mastering High-Concurrency Caching: Penetration, Breakdown, Avalanche & Hot Keys
liandk
liandk
Oct 4, 2026 · Backend Development

High-Concurrency Flash Sale Architecture: Layered Rate Limiting, Overselling Prevention & Cache Protection

This article details a production-grade five-layer architecture for high-concurrency flash sale systems, covering traffic shaping via message queues, multi-level rate limiting, three-tier overselling prevention using Redis atomic operations and database optimistic locking, and solutions for cache penetration, breakdown, and avalanche, plus nine common failure scenarios and a troubleshooting SOP.

Message QueueRediscache protection
0 likes · 17 min read
High-Concurrency Flash Sale Architecture: Layered Rate Limiting, Overselling Prevention & Cache Protection
ITPUB
ITPUB
Sep 30, 2026 · Artificial Intelligence

How AI Agents Handle High Concurrency: Admission, Backpressure, Async & Isolation

This article details a production-grade architecture for handling high concurrency in AI agent systems, covering real load estimation, admission control with bounded queues, async task processing, hierarchical concurrency budgets for models and tools, resource isolation via bulkheads, idempotency for state consistency, graded degradation strategies, and observability-driven capacity planning.

AI agentsConcurrency BudgetIdempotency
0 likes · 18 min read
How AI Agents Handle High Concurrency: Admission, Backpressure, Async & Isolation
Rain's Path to Java Mastery
Rain's Path to Java Mastery
Sep 29, 2026 · Backend Development

10 System Design Questions That Decide Big Tech Interview Success

This article dissects 10 high-frequency system design questions — seckill, short URL, distributed ID, delayed tasks, leaderboard, real-time push, short-video feed, sharding, rate limiting, and config center — with architecture diagrams, core code, and comparative solutions for each.

Backend ArchitectureDistributed SystemsMessage Queue
0 likes · 73 min read
10 System Design Questions That Decide Big Tech Interview Success
Xiaolin Talks Programming
Xiaolin Talks Programming
Sep 22, 2026 · Backend Development

Spring Boot Tomcat Tuning: Breaking the 4K QPS Ceiling with Thread Pool & Keep-Alive Config

This article details how default Spring Boot Tomcat settings (maxThreads=200) cap throughput at ~4K QPS despite low CPU, and demonstrates step-by-step tuning of thread pool, connection limits, and Keep-Alive parameters using Little's Law and load testing to achieve 10K+ QPS with 800 threads and proper monitoring.

Keep-AliveLittle's LawPerformance Tuning
0 likes · 17 min read
Spring Boot Tomcat Tuning: Breaking the 4K QPS Ceiling with Thread Pool & Keep-Alive Config
Internet Backend Architecture Stack
Internet Backend Architecture Stack
Sep 19, 2026 · Backend Development

Distributed ID Deep Dive: Snowflake vs Segment Mode – Trade-offs, Pitfalls & Production Patterns

This article analyzes real-world e-commerce failures to compare Snowflake and Segment ID generation, exposing architectural pitfalls like time rollback, machine ID collisions, and blocking windows, while providing production-ready code patterns and a decision matrix for choosing between ordered consistency and high-throughput availability.

Architecture DesignDistributed SystemsJava
0 likes · 22 min read
Distributed ID Deep Dive: Snowflake vs Segment Mode – Trade-offs, Pitfalls & Production Patterns
Cloud Architecture
Cloud Architecture
Sep 18, 2026 · Databases

From Ad-Hoc Indexing to Verifiable Governance: MySQL Index Governance at Scale

This article details a production-grade MySQL index governance system for high-concurrency e-commerce, covering evidence collection, invisible index validation, automated change gates, regression detection, and a case study reducing order-list P99 from 2.3s to 170ms while preventing unsafe deletions.

Query Optimizatione-commercehigh concurrency
0 likes · 38 min read
From Ad-Hoc Indexing to Verifiable Governance: MySQL Index Governance at Scale
JD Tech
JD Tech
Sep 16, 2026 · Backend Development

18 Battle-Tested Java Coding Techniques for High-Performance, Low-CPU Systems (Part 1)

This article presents 18 practical coding techniques derived from million-QPS production systems to reduce CPU consumption and improve performance, covering type unification, string handling, loop optimization, caching strategies, and data structure selection with concrete before/after code examples.

CPU optimizationCoding Best PracticesGC Reduction
0 likes · 67 min read
18 Battle-Tested Java Coding Techniques for High-Performance, Low-CPU Systems (Part 1)
Random Bulletin
Random Bulletin
Sep 15, 2026 · Operations

Structured Incident Response at 10M QPS: From Random to Process-Driven

This article details a comprehensive framework for transforming ad-hoc incident response into a structured, repeatable process for high-concurrency systems, covering incident state machines, role definitions, severity grading, first 15-minute checklists, timeline management, automation, blameless postmortems, and evolutionary stages from visibility to organizational learning.

automationblameless culturehigh concurrency
0 likes · 30 min read
Structured Incident Response at 10M QPS: From Random to Process-Driven
ITPUB
ITPUB
Sep 6, 2026 · Backend Development

How WeChat Resets 1 Billion Step Counts at Midnight Without Crashing

WeChat avoids server crashes during midnight step-count resets for 1 billion users by using logical time-based versioning instead of physical updates, a custom PaxosStore for atomic increments, delayed double-write buffers for clock skew, Redis ZSet sharding for rankings, and asynchronous cold-data archival during low-traffic hours.

Distributed SystemsPaxosStoreRedis
0 likes · 18 min read
How WeChat Resets 1 Billion Step Counts at Midnight Without Crashing
Rain's Path to Java Mastery
Rain's Path to Java Mastery
Aug 30, 2026 · Backend Development

Deduplicating 10 Billion Orders: Bloom Filter + Redis Architecture Deep Dive

This article details a production-grade solution for deduplicating 10 billion order numbers using a sharded Redis Bloom filter with database fallback, covering parameter calculations, cold-start loading, scaling strategies, consistency guarantees, and interview-focused comparisons with offline batch and real-time stream approaches.

Bloom filterCold StartRedis
0 likes · 26 min read
Deduplicating 10 Billion Orders: Bloom Filter + Redis Architecture Deep Dive
Cloud Architecture
Cloud Architecture
Aug 26, 2026 · Backend Development

From Zero to Production: High‑Concurrency Netty TCP Server for Cloud‑Native

This article walks through building a production‑grade Netty TCP server, covering protocol design, reactor threading, back‑pressure handling, session management, authentication, heartbeats, scaling to hundreds of thousands of connections, cloud‑native deployment, graceful shutdown, observability, reliability, and security considerations.

Cloud NativeNettyProtocol Design
0 likes · 45 min read
From Zero to Production: High‑Concurrency Netty TCP Server for Cloud‑Native
Ray's Galactic Tech
Ray's Galactic Tech
Aug 25, 2026 · Backend Development

How to Secure Wallet Funds at Billion‑Scale Through Reconciliation: Balance Checks, Channel Matching, and Auto‑Repair

In high‑throughput wallet systems, reconciliation—covering internal balance validation, channel‑level matching, and controlled auto‑repair—acts as the final safeguard against fund discrepancies caused by lost callbacks, out‑of‑order events, duplicate entries, or concurrency conflicts, ensuring financial safety even with billions of daily transactions.

Distributed Systemsauto-repairbalance-validation
0 likes · 33 min read
How to Secure Wallet Funds at Billion‑Scale Through Reconciliation: Balance Checks, Channel Matching, and Auto‑Repair
Ray's Galactic Tech
Ray's Galactic Tech
Aug 24, 2026 · Backend Development

Decoupling Payments and Wallets: From Order Domain to a Unified Accounting Center

The article walks through why embedding a wallet in the order service leads to boundary violations and failures under load, and presents a step‑by‑step evolution from an order‑centric wallet to a dedicated, event‑driven accounting center that ensures consistency, auditability, and high‑throughput scalability.

IdempotencyOutbox Patternaccounting
0 likes · 42 min read
Decoupling Payments and Wallets: From Order Domain to a Unified Accounting Center
Architect Chen
Architect Chen
Aug 24, 2026 · Operations

6 Nginx Configuration Optimizations for High-Concurrency Performance

This article details six essential Nginx configuration optimizations for high-concurrency scenarios, covering worker processes, connection limits, epoll event model, TCP reuse via sendfile and TCP options, HTTP keepalive, and upstream connection pooling with concrete examples and configuration snippets.

EpollNginxconfiguration-optimization
0 likes · 5 min read
6 Nginx Configuration Optimizations for High-Concurrency Performance
Ray's Galactic Tech
Ray's Galactic Tech
Aug 22, 2026 · Backend Development

High-Concurrency Wallet Design: Hot Accounts, Idempotent Deductions, and Sharding Practices

The article analyses why wallet balance deduction is more error‑prone than inventory, outlines the root causes of a real‑world 60 k TPS outage, and presents a production‑grade architecture that separates strong‑consistent user deductions from asynchronous hot‑account crediting using idempotent requests, unique DB constraints, sharding, outbox messaging, and comprehensive monitoring to guarantee financial correctness under extreme load.

IdempotencyOutboxScaling
0 likes · 32 min read
High-Concurrency Wallet Design: Hot Accounts, Idempotent Deductions, and Sharding Practices
Ray's Galactic Tech
Ray's Galactic Tech
Aug 20, 2026 · Backend Development

Why Wallet Balance Shouldn't Be Calculated On‑The‑Fly: Double‑Entry Accounting, Snapshots, and Immutable Ledger Practices

The article explains that a production‑grade wallet must store balance snapshots instead of summing transaction flows, using double‑entry bookkeeping, ACID guarantees, idempotent request handling, outbox messaging, sharding, and comprehensive reconciliation to ensure correctness and high‑throughput under heavy concurrency.

IdempotencyOutbox Patternbalance snapshot
0 likes · 43 min read
Why Wallet Balance Shouldn't Be Calculated On‑The‑Fly: Double‑Entry Accounting, Snapshots, and Immutable Ledger Practices
Mike Chen Rui
Mike Chen Rui
Aug 19, 2026 · Backend Development

What TPS Levels Define a High‑Performance E‑Commerce Flash Sale?

The article explains how flash‑sale systems differ from regular e‑commerce, outlines characteristic traffic spikes, and defines TPS ranges—100‑1,000, 1,000‑5,000, 5,000‑10,000, and 10,000‑50,000—that indicate low, medium, mature, and ultra‑high concurrency, while noting the architectural techniques needed to sustain tens of thousands of requests.

Message QueueRedisScaling
0 likes · 4 min read
What TPS Levels Define a High‑Performance E‑Commerce Flash Sale?
Architecture Digest
Architecture Digest
Aug 18, 2026 · Backend Development

How to Design a ThreadPool to Send 10 Million SMS in One Hour – Interview Insights

Sending 10 million marketing SMS within an hour forces careful thread‑pool design: avoid unbounded queues that cause OOM, choose a bounded ThreadPoolExecutor, dynamically tune core/max sizes, use CallerRunsPolicy for natural back‑pressure, and add persistence and compensation mechanisms to guarantee reliability.

Java ConcurrencyOOM preventionThreadPoolExecutor
0 likes · 8 min read
How to Design a ThreadPool to Send 10 Million SMS in One Hour – Interview Insights
Java Architect Handbook
Java Architect Handbook
Aug 17, 2026 · Backend Development

Interview Question: What Is Flash‑Sale Warmup and Why Does It Matter?

The article explains warmup (prewarm) as the practice of moving a Java system from a cold to a hot state before traffic arrives, covering JVM JIT compilation, cache preloading, connection‑pool and thread‑pool initialization, service gray‑release, and how these steps prevent cold‑start failures in high‑concurrency scenarios.

CacheConnection PoolJVM
0 likes · 13 min read
Interview Question: What Is Flash‑Sale Warmup and Why Does It Matter?
Cloud Architecture
Cloud Architecture
Aug 16, 2026 · Backend Development

How to Build a 100k QPS Seckill System with Spring Boot, Redis, and Lua

This article provides a production‑grade, step‑by‑step engineering guide for designing a high‑concurrency seckill (flash‑sale) system that can sustain 100,000 QPS using Spring Boot, Redis with Lua scripts, asynchronous messaging, and comprehensive fault‑tolerance, monitoring, and scalability techniques.

Distributed SystemsLuaRedis
0 likes · 40 min read
How to Build a 100k QPS Seckill System with Spring Boot, Redis, and Lua
MaGe Linux Operations
MaGe Linux Operations
Aug 16, 2026 · Operations

Tuning Nginx Worker Processes and Connections for High‑Concurrency Scenarios

This guide walks through the complete workflow for analyzing, configuring, and validating Nginx in high‑traffic environments, covering architecture basics, core parameters, system limits, practical configuration examples, stress‑testing methods, monitoring, risk mitigation, rollback procedures, and production‑grade best practices.

Nginxhigh concurrencyload balancing
0 likes · 23 min read
Tuning Nginx Worker Processes and Connections for High‑Concurrency Scenarios
Code Farming
Code Farming
Aug 14, 2026 · Backend Development

How Weibo Handles 100k QPS During Viral Peaks: Architectural Secrets

The article breaks down how Weibo’s backend was engineered to sustain 100,000 queries per second during traffic surges by first quantifying load, then using a push‑pull hybrid feed, a four‑tier cache funnel, and user‑ID sharding with write throttling.

backend designcachingfeed architecture
0 likes · 8 min read
How Weibo Handles 100k QPS During Viral Peaks: Architectural Secrets
Java Tech Workshop
Java Tech Workshop
Aug 11, 2026 · Backend Development

Achieving 6 Million Orders per Second with SpringBoot and LMAX Disruptor

The article explains why traditional Java BlockingQueue struggles under high load, introduces the LMAX Disruptor’s lock‑free ring buffer design, compares performance showing up to 600 万+ events per second versus 100 万 for ArrayBlockingQueue, and provides step‑by‑step SpringBoot integration with code examples and best‑practice tips.

DisruptorJavaSpringBoot
0 likes · 17 min read
Achieving 6 Million Orders per Second with SpringBoot and LMAX Disruptor
Code Farming
Code Farming
Aug 9, 2026 · Backend Development

How a System Handles 30 Million Simultaneous Video Views

The article breaks down how QuickTok supports 30 million concurrent video streams by calculating QPS, storage and bandwidth needs, then applying HDFS with HBase indexing and aggressive CDN pre‑warming to shrink traffic from 88 Tbps to under 4 Tbps.

CDNHDFSVideo Streaming
0 likes · 5 min read
How a System Handles 30 Million Simultaneous Video Views
Java Tech Enthusiast
Java Tech Enthusiast
Aug 9, 2026 · Backend Development

Spring Boot + Disruptor: Achieving Ultra‑Fast High‑Concurrency Processing for 6 Million Orders per Second

This article explains how to replace traditional message queues with LMAX Disruptor in a Spring Boot application, covering its core concepts, step‑by‑step implementation, and a demo that demonstrates lock‑free, high‑throughput processing capable of handling six million orders per second.

DisruptorJavaMessage Queue
0 likes · 10 min read
Spring Boot + Disruptor: Achieving Ultra‑Fast High‑Concurrency Processing for 6 Million Orders per Second
Rain's Path to Java Mastery
Rain's Path to Java Mastery
Aug 8, 2026 · Backend Development

Production API Overload: Emergency Response, Root Cause Analysis & Resilience Patterns

A comprehensive guide to handling production API overload covering emergency mitigation (rate limiting, degradation, circuit breaking), root cause diagnosis via monitoring and tracing, long-term optimizations (caching, async, DB tuning), with practical Java code for Sentinel, Caffeine+Redis, CompletableFuture, and Bloom filters, plus interview-ready troubleshooting frameworks.

Bloom filterCaffeineCompletableFuture
0 likes · 32 min read
Production API Overload: Emergency Response, Root Cause Analysis & Resilience Patterns
Ray's Galactic Tech
Ray's Galactic Tech
Aug 6, 2026 · Databases

Taming Message Storms: Redis 7.x Engineering Practices for Enterprise Live‑Streaming Platforms

This article dissects why a simple Redis upgrade is insufficient for large‑scale live streaming, then walks through how Redis 7’s Sharded Pub/Sub, Function, and ACL v2 features together eliminate broadcast storms, streamline script governance, and enforce fine‑grained multi‑tenant control, backed by concrete architecture diagrams, production‑grade Java code, capacity planning, monitoring, rollout procedures, and real‑world benchmark results.

ACLRedisRedis Function
0 likes · 41 min read
Taming Message Storms: Redis 7.x Engineering Practices for Enterprise Live‑Streaming Platforms
Mike Chen Rui
Mike Chen Rui
Aug 6, 2026 · Operations

Hands‑on Nginx High‑Concurrency Tuning: Boost Performance Up to 10×

This article walks through practical Nginx high‑concurrency tuning steps—including worker_processes, worker_connections, Linux file‑descriptor limits, and sendfile zero‑copy settings—to dramatically increase throughput and handle tens of thousands of simultaneous connections.

NginxPerformance Tuninghigh concurrency
0 likes · 3 min read
Hands‑on Nginx High‑Concurrency Tuning: Boost Performance Up to 10×
Code Farming
Code Farming
Aug 5, 2026 · Backend Development

How to Generate Billions of Conflict‑Free Short URLs

The article breaks down a real‑world architecture for a short‑URL service that must handle 12 billion entries and 40 k QPS, showing how to calculate capacity, compare generation algorithms, use Bloom filters for offline de‑duplication, and employ a three‑layer cache‑plus‑storage design to meet performance goals.

Bloom filterHBaseRedis
0 likes · 7 min read
How to Generate Billions of Conflict‑Free Short URLs
Mike Chen Rui
Mike Chen Rui
Aug 5, 2026 · Backend Development

How Can a Gateway Sustain Million‑Level Concurrency in High‑Traffic Scenarios?

The article explains why a gateway is the first traffic entry in microservice systems and how Spring Cloud Gateway achieves million‑level concurrent handling through a reactive model, non‑blocking I/O, event‑driven scheduling, zero‑copy transmission, and built‑in rate‑limiting mechanisms.

Spring Cloud GatewayZero-Copyevent-driven
0 likes · 3 min read
How Can a Gateway Sustain Million‑Level Concurrency in High‑Traffic Scenarios?
Code Farming
Code Farming
Aug 4, 2026 · Backend Development

Why 50,000 Simultaneous Registrations Crashed the System—and How Isolation Prevents It

When an education company faced 50,000 concurrent re‑registration requests, its monolithic internal‑external architecture collapsed, but by physically separating networks, enforcing gateway rate‑limiting and circuit‑breaking, pre‑loading data into Redis, and using one‑way Kafka streams, the system remained stable.

Backend ArchitectureCircuit BreakingKafka
0 likes · 6 min read
Why 50,000 Simultaneous Registrations Crashed the System—and How Isolation Prevents It
Ray's Galactic Tech
Ray's Galactic Tech
Aug 4, 2026 · Backend Development

Spring Boot & Netty MQTT Platform: Multi‑Protocol and Modular Design

This guide walks through building a high‑performance, scalable MQTT access gateway for IoT using Spring Boot for service orchestration and Netty for connection handling, covering protocol fundamentals, modular architecture, multi‑protocol adaptation, session management, high‑concurrency optimizations, clustering, observability, and deployment best practices.

IoTKubernetesMQTT
0 likes · 40 min read
Spring Boot & Netty MQTT Platform: Multi‑Protocol and Modular Design
Rain's Path to Java Mastery
Rain's Path to Java Mastery
Jul 31, 2026 · Backend Development

Redis Cache Penetration, Breakdown & Avalanche: Java Solutions & Production Lessons

This article analyzes Redis cache penetration, breakdown, and avalanche — three high-concurrency failure modes — detailing root causes, solutions like Bloom filters, logical expiration, and multi-level caching, with production-ready Java code, real incident postmortems, and interview-focused technical comparisons.

Bloom filterCaffeineJava
0 likes · 32 min read
Redis Cache Penetration, Breakdown & Avalanche: Java Solutions & Production Lessons
Code Farming
Code Farming
Jul 30, 2026 · Backend Development

Can Your System Survive a Sudden 500K Live Viewers? 4 Proven Traffic‑Splitting Techniques

When a live broadcast suddenly attracts 500,000 viewers, the system faces 100,000 QPS likes and rapid reward transactions; this article breaks down a battle‑tested traffic‑splitting architecture—room‑based sharding, queue buffering, multi‑layer write caching, and consistent‑hash sharding—showing how each component controls load, ensures consistency, and enables seamless scaling.

consistent-hashingdistributed cachehigh concurrency
0 likes · 6 min read
Can Your System Survive a Sudden 500K Live Viewers? 4 Proven Traffic‑Splitting Techniques
Mike Chen Rui
Mike Chen Rui
Jul 27, 2026 · Backend Development

What Defines High‑Concurrency for Nginx? A Clear Guide

The article explains that “high concurrency” for Nginx is relative, depends on hardware, request type, response size, and overall architecture, and provides typical connection and QPS ranges for ordinary, medium, high‑traffic, and ultra‑high‑traffic systems.

NginxQPSconnection limits
0 likes · 2 min read
What Defines High‑Concurrency for Nginx? A Clear Guide
Cloud Architecture
Cloud Architecture
Jul 26, 2026 · Backend Development

Seckill System Architecture: 7 Core Design Strategies for High-Concurrency Sales

This article presents a comprehensive, step‑by‑step analysis of building a flash‑sale (seckill) system that can survive instant traffic spikes, detailing seven essential design ideas such as static page delivery, token gating, Redis atomic decrement, asynchronous queuing, multi‑layer rate limiting, service isolation, idempotent processing, and end‑to‑end monitoring and recovery.

Distributed SystemsIdempotencyLua
0 likes · 28 min read
Seckill System Architecture: 7 Core Design Strategies for High-Concurrency Sales
Architect's Guide
Architect's Guide
Jul 25, 2026 · Backend Development

The Art of Building a High‑Concurrency Flash‑Sale System

This article dissects the architecture of a massive flash‑sale service like 12306, covering multi‑layer load balancing, Nginx weighted round‑robin, stock‑deduction strategies, a Go‑based implementation with Redis and Lua, and performance results that demonstrate handling millions of concurrent ticket requests.

GoNginxRedis
0 likes · 22 min read
The Art of Building a High‑Concurrency Flash‑Sale System
Random Bulletin
Random Bulletin
Jul 23, 2026 · Backend Development

From Threads to Coroutines: Scaling to Millions of QPS

The article explains why the traditional one‑request‑one‑thread model collapses at tens of thousands of connections due to memory, scheduling and cache costs, and shows how user‑space coroutine scheduling, stack‑less designs, Go's GMP model, Java virtual threads and CSP channels enable millions of concurrent connections with synchronous‑style code while highlighting trade‑offs and pitfalls.

CSPCoroutinesGo
0 likes · 21 min read
From Threads to Coroutines: Scaling to Millions of QPS
samdeepthink
samdeepthink
Jul 23, 2026 · Backend Development

Enterprise-Scale Source Code for 4 Real-World Projects: Flash Sale, Product Catalog, Payment System, and DDD Implementation

The author releases the complete, production‑ready source code for four enterprise‑level projects—a flash‑sale service handling 60 million members, a high‑concurrency product system for hundreds of millions of users, a payment platform serving over a hundred million users, and a three‑year DDD migration case study—while the fifth column remains under development.

DDDJavaPayment Integration
0 likes · 5 min read
Enterprise-Scale Source Code for 4 Real-World Projects: Flash Sale, Product Catalog, Payment System, and DDD Implementation
Code Farming
Code Farming
Jul 20, 2026 · Backend Development

How a Message Queue Keeps Flash‑Sale Systems Stable Under 10k Orders per Second

The article explains how using a message queue as a buffer, asynchronous processor, and decoupling layer enables flash‑sale systems to handle tens of thousands of orders per second, reducing database overload, cutting response time from 500 ms to 50 ms, and preventing cascade failures.

Asynchronous ProcessingDecouplingMessage Queue
0 likes · 5 min read
How a Message Queue Keeps Flash‑Sale Systems Stable Under 10k Orders per Second
Random Bulletin
Random Bulletin
Jul 19, 2026 · Backend Development

From BIO to Async IO: Evolving Thread Models for Million‑QPS Servers

An online gateway crashed despite low CPU and memory because its one‑connection‑one‑thread BIO model exhausted threads, prompting a deep dive into thread‑pool limits, epoll, Reactor patterns, Proactor, and back‑pressure, showing how each evolution decouples connections from resource consumption to achieve million‑QPS scalability.

BIOEpollReactor
0 likes · 18 min read
From BIO to Async IO: Evolving Thread Models for Million‑QPS Servers
Ray's Galactic Tech
Ray's Galactic Tech
Jul 17, 2026 · Artificial Intelligence

High‑Concurrency RAG: When to Use Classic, Graph or Agentic Architecture

The article analyzes why production‑grade RAG systems fail under load and explains how Classic, Graph, and Agentic RAG each address specific problem stages, offering concrete engineering guidelines for query normalization, caching, versioned knowledge, graph construction, stateful agents, and governance to achieve stable high‑throughput performance.

Agentic RAGGraph RAGKnowledge Governance
0 likes · 31 min read
High‑Concurrency RAG: When to Use Classic, Graph or Agentic Architecture
Xiaolin Talks Programming
Xiaolin Talks Programming
Jul 17, 2026 · Backend Development

Spring StateMachine in Production: Modeling, Redis Persistence & High-Concurrency Anti-Duplication Patterns

This article shares real-world experience using Spring StateMachine to replace sprawling if-else logic in order systems, covering state/event/guard modeling, Redis-backed persistence, a three-layer concurrency control pattern (distributed lock + optimistic lock + event idempotency), async decoupling, timeout handling, and compensation strategies with concrete code templates.

IdempotencyOptimistic LockRedis Persistence
0 likes · 17 min read
Spring StateMachine in Production: Modeling, Redis Persistence & High-Concurrency Anti-Duplication Patterns
Ray's Galactic Tech
Ray's Galactic Tech
Jul 16, 2026 · Backend Development

Building a Scalable Smart Tag System for 100k QPS with AI‑Generated Code

The article explains that while many teams focus on model accuracy, the real challenges of an AI‑powered tagging system are write spikes, timeouts, duplicate tagging, cost overruns and state inconsistency, and it proposes a five‑layer architecture, async fallback, governance and validation practices to reliably achieve a 100 k QPS target.

AI taggingKafkaLLM integration
0 likes · 30 min read
Building a Scalable Smart Tag System for 100k QPS with AI‑Generated Code
Java Tech Workshop
Java Tech Workshop
Jul 15, 2026 · Backend Development

Generating Trillions of Unique Order IDs Without Collisions

The article analyzes why simple auto‑increment or timestamp‑based IDs fail at massive scales, compares common distributed ID schemes, and presents an improved Snowflake‑plus‑segment hybrid solution with clock‑rollback protection, automatic machine/room allocation, and production‑grade safeguards for trillion‑level order processing.

JavaSnowflakedistributed-id
0 likes · 19 min read
Generating Trillions of Unique Order IDs Without Collisions
Ray's Galactic Tech
Ray's Galactic Tech
Jul 14, 2026 · Cloud Native

Spring Boot + Netty MQTT Gateway for Million Connections & Millisecond Push

To support millions of persistent MQTT connections with sub‑millisecond latency, the article walks through a Spring Boot + Netty cloud‑native gateway design that separates connection, event, state and governance planes, details async authentication, back‑pressure handling, command state machines, and loss‑less Kubernetes roll‑outs.

Cloud NativeKafkaKubernetes
0 likes · 38 min read
Spring Boot + Netty MQTT Gateway for Million Connections & Millisecond Push
Random Bulletin
Random Bulletin
Jul 14, 2026 · Backend Development

When 10 Million QPS Hits: Why Switching from Sync to Async Becomes Mandatory

The article explains how, at the ten‑million‑QPS scale, the hidden cost of thread‑bound synchronous calls—memory, scheduling overhead, and stability risks—explodes, making asynchronous architectures essential, and outlines the trade‑offs, gradual migration paths, and scenarios where async should or should not be applied.

Asynchronous ProgrammingPerformance Optimizationhigh concurrency
0 likes · 19 min read
When 10 Million QPS Hits: Why Switching from Sync to Async Becomes Mandatory
Code Farming
Code Farming
Jul 13, 2026 · Backend Development

Mastering Traffic Control: Keeping Systems Stable Under a Million Concurrent Requests

The article explains how to prevent system crashes during massive traffic spikes by applying three core techniques—rate limiting, circuit breaking, and graceful degradation—detailing algorithm choices, state machines, and practical implementation steps for high‑concurrency back‑end services.

Backendcircuit breakerdegradation
0 likes · 6 min read
Mastering Traffic Control: Keeping Systems Stable Under a Million Concurrent Requests
Cloud Architecture
Cloud Architecture
Jul 13, 2026 · Backend Development

Production-Grade Payment System Guide: Java Implementation for Alipay & WeChat All-Channel Integration

This article explains why a payment system is more than a simple SDK integration, presents a four‑layer architecture (access, state, event, governance), details state machines, idempotent callbacks, outbox pattern, reconciliation, high‑concurrency handling, observability, security, and provides Java code examples for integrating Alipay and WeChat across all channels.

AlipayIdempotencyJava
0 likes · 29 min read
Production-Grade Payment System Guide: Java Implementation for Alipay & WeChat All-Channel Integration
Architect Chen
Architect Chen
Jul 13, 2026 · Databases

How I/O Multiplexing Gives Redis a 10× Performance Boost

Redis achieves its high speed not only because it is an in‑memory, single‑threaded database with efficient data structures, but primarily thanks to I/O multiplexing, which lets a single thread manage tens of thousands of client connections, dramatically cutting thread‑switch overhead and boosting throughput up to tenfold.

EpollI/O multiplexingPerformance Optimization
0 likes · 4 min read
How I/O Multiplexing Gives Redis a 10× Performance Boost
Code Farming
Code Farming
Jul 13, 2026 · Backend Development

Designing Trillion‑Scale Counters: From MySQL to a Custom Redis Engine

The article dissects a proven trillion‑level counter architecture, tracing its evolution from a simple MySQL table through hash sharding, a full Redis migration, deep Redis memory optimizations, and hot‑cold separation, while detailing the trade‑offs and performance gains at each step.

Message QueueRedis optimizationcounter architecture
0 likes · 6 min read
Designing Trillion‑Scale Counters: From MySQL to a Custom Redis Engine
YiSu Grain
YiSu Grain
Jul 9, 2026 · Backend Development

Mapping Database & Architecture Patterns onto an E‑Commerce High‑Concurrency Diagram

This article reviews weeks 8‑13 of a system‑architecture course—covering indexes, ACID, MVCC, high availability, performance tuning, and case‑study templates—and shows how to combine those concepts into a complete e‑commerce high‑concurrency solution with caching, load‑balancing, async processing, database optimization, HA clustering, and concurrency control.

High Availabilitycachingdatabase optimization
0 likes · 18 min read
Mapping Database & Architecture Patterns onto an E‑Commerce High‑Concurrency Diagram
Cloud Architecture
Cloud Architecture
Jul 9, 2026 · Backend Development

How Spring Boot, Kafka, Redis, and MongoDB Power Real‑Time GPS Tracking for Millions of Vehicles

This article walks through a production‑grade architecture that uses Spring Boot, Kafka, Redis, and MongoDB to ingest, buffer, order, and store high‑frequency vehicle GPS data from hundreds of thousands of devices while guaranteeing low latency, scalability, fault‑tolerance, and accurate replay capabilities.

KafkaMongoDBRedis
0 likes · 38 min read
How Spring Boot, Kafka, Redis, and MongoDB Power Real‑Time GPS Tracking for Millions of Vehicles
Cloud Architecture
Cloud Architecture
Jul 8, 2026 · Backend Development

High‑Concurrency Order System Architecture: How Redis, MySQL, and Elasticsearch Collaborate Without Overstepping

This article presents a production‑grade, high‑concurrency order system design that separates responsibilities among Redis for traffic control, MySQL as the single source of truth, Kafka for event propagation, and Elasticsearch for search, while detailing state‑machine modeling, outbox patterns, seckill flow, and comprehensive observability and deployment practices.

ElasticsearchOutboxRedis
0 likes · 31 min read
High‑Concurrency Order System Architecture: How Redis, MySQL, and Elasticsearch Collaborate Without Overstepping
Cloud Architecture
Cloud Architecture
Jul 7, 2026 · Backend Development

From HTTP Polling to MQTT Push: Evolving High‑Concurrency IoT Device Access Architecture

Switching from HTTP polling to MQTT for massive IoT deployments requires rethinking connection models, topic design, state management, and engineering practices, as the article details the architectural evolution, four‑plane production design, code patterns, and operational safeguards needed for reliable high‑concurrency device access.

IoTMQTTOutbox
0 likes · 46 min read
From HTTP Polling to MQTT Push: Evolving High‑Concurrency IoT Device Access Architecture
Code Farming
Code Farming
Jul 7, 2026 · Backend Development

Four Ways to Ensure Unique IDs After Database Sharding

When a system is split into multiple databases and tables, the article explains the root cause of ID collisions and compares four mainstream ID generation strategies—UUID, database auto‑increment, Snowflake, and segment allocation—detailing their trade‑offs, pitfalls, and selection guidelines for different concurrency levels.

Snowflakedistributed-idhigh concurrency
0 likes · 9 min read
Four Ways to Ensure Unique IDs After Database Sharding
IT Learning Made Simple
IT Learning Made Simple
Jul 6, 2026 · Backend Development

How Chaotic Architecture Can Sink an E‑commerce Business – Lessons from the Drama “E‑commerce Storm”

The article uses the drama “E‑commerce Storm” to illustrate how failures in the four‑layer e‑commerce architecture—front‑end, business logic, data persistence, and server/operations—lead to order chaos, permission breaches, database crashes, and DDoS attacks, and shows how refactoring and security hardening can prevent collapse.

Cloud OperationsRBACdatabase backup
0 likes · 6 min read
How Chaotic Architecture Can Sink an E‑commerce Business – Lessons from the Drama “E‑commerce Storm”
Subtle Storm
Subtle Storm
Jul 1, 2026 · Backend Development

How to Tackle the “Three Highs” of Internet Systems Without Burning Out

The article analyzes the intertwined challenges of high concurrency, high performance, and high availability in internet services, explains why they cannot all be maximized simultaneously, and presents concrete architectural tactics—partitioning, caching, async processing, redundancy, and CAP trade‑offs—to achieve a balanced, resilient system.

CAP theoremDistributed SystemsHigh Availability
0 likes · 7 min read
How to Tackle the “Three Highs” of Internet Systems Without Burning Out
Cloud Architecture
Cloud Architecture
Jun 29, 2026 · Databases

Deep Guide to MySQL Index Failure: From Core Mechanics to High‑Concurrency Production Practices

This comprehensive guide explains why seemingly indexed MySQL queries can still cause severe latency spikes in high‑traffic systems, explores the underlying InnoDB structures and optimizer cost model, enumerates twelve common failure patterns with concrete SQL examples, and provides a production‑grade methodology for diagnosing, engineering, and automating index governance.

InnoDBPerformance Tuninghigh concurrency
0 likes · 39 min read
Deep Guide to MySQL Index Failure: From Core Mechanics to High‑Concurrency Production Practices
Cloud Architecture
Cloud Architecture
Jun 27, 2026 · Backend Development

Enterprise Messaging System Deep Dive: Core Engine to High‑Concurrency

This guide explains how enterprise messaging systems reliably propagate state changes across distributed services, covering core concepts, outbox patterns, topic/tag modeling, consumer idempotency, dead‑letter handling, high‑concurrency engineering, monitoring, and Kubernetes deployment to build a production‑grade, observable platform.

KafkaOutboxevent-driven
0 likes · 44 min read
Enterprise Messaging System Deep Dive: Core Engine to High‑Concurrency
Cloud Architecture
Cloud Architecture
Jun 25, 2026 · Backend Development

SpringBoot + WeChat Pay V3: Architecture for Million-Concurrent Payments

The article explains how to build a production‑grade, million‑concurrent payment pipeline with SpringBoot and WeChat Pay V3, covering the new security model, state‑machine design, idempotent handling, decoupled architecture, compensation mechanisms, and operational best practices such as connection‑pool tuning, observability, and fault‑tolerant deployment.

SpringBootWeChat Paycompensation
0 likes · 56 min read
SpringBoot + WeChat Pay V3: Architecture for Million-Concurrent Payments
Cloud Architecture
Cloud Architecture
Jun 25, 2026 · Backend Development

Four Production‑Grade Defenses Against Redis Cache Penetration in High‑Concurrency Microservices

The article explains how non‑existent data amplified by high concurrency can cause cache penetration, distinguishes it from cache breakdown and avalanche, and presents a layered defense—entry validation, Bloom filter existence checks, negative caching, and concurrent‑request convergence—plus practical code, metrics, and operational checklists for robust microservice deployments.

Bloom filterNegative CacheRedis
0 likes · 28 min read
Four Production‑Grade Defenses Against Redis Cache Penetration in High‑Concurrency Microservices
Mike Chen's Internet Architecture
Mike Chen's Internet Architecture
Jun 25, 2026 · Backend Development

Why Nginx Can Handle Tens of Millions of Requests

The article explains how Nginx’s event‑driven, asynchronous non‑blocking model, master‑worker multi‑process design, efficient I/O multiplexing (epoll/kqueue), and lightweight resource‑control architecture enable it to sustain extremely high concurrency with minimal overhead.

I/O multiplexingNginxasynchronous
0 likes · 5 min read
Why Nginx Can Handle Tens of Millions of Requests
Cloud Architecture
Cloud Architecture
Jun 23, 2026 · Databases

Why Redis Handles Millions of Concurrent Requests: Event Loop and Cluster Design

Redis sustains millions of concurrent operations not merely because it is single‑threaded, but thanks to its non‑blocking event‑loop I/O, compact in‑memory data structures, serialized command execution that eliminates lock contention, and robust production features such as replication, sharding, persistence, observability and governance.

ClusterLua ScriptingRedis
0 likes · 40 min read
Why Redis Handles Millions of Concurrent Requests: Event Loop and Cluster Design
Cloud Architecture
Cloud Architecture
Jun 22, 2026 · Backend Development

Dubbo vs Spring Cloud: Deep Dive for Billion‑Scale Microservice Architecture

The article examines how to choose between Dubbo and Spring Cloud for high‑traffic microservice systems, analyzing communication models, thread and connection handling, governance capabilities, real‑world e‑commerce scenarios, and provides practical guidance on combining HTTP gateways, RPC, and asynchronous messaging for scalable, resilient architectures.

DubboKubernetesService Governance
0 likes · 32 min read
Dubbo vs Spring Cloud: Deep Dive for Billion‑Scale Microservice Architecture
Mike Chen's Internet Architecture
Mike Chen's Internet Architecture
Jun 22, 2026 · Operations

How to Tune Nginx Kernel Parameters for Up to 10× Performance Boost

The article walks through a step‑by‑step Nginx performance tuning guide, covering worker_processes and worker_connections settings, Linux file‑descriptor limits, sysctl tweaks such as net.core.somaxconn and tcp_max_syn_backlog, explicit listen backlog, and zero‑copy sendfile with tcp_nopush/tcp_nodelay to dramatically increase throughput and lower CPU usage.

Performance TuningZero-Copyhigh concurrency
0 likes · 4 min read
How to Tune Nginx Kernel Parameters for Up to 10× Performance Boost
Smart Era Software Development
Smart Era Software Development
Jun 22, 2026 · Artificial Intelligence

Constrained Autonomy: An Agentic Architecture Scaling to Hundreds of Thousands of Creators

The talk details a multi‑agent system for AI video creation that tackles orchestration uncertainty, fault irrecoverability, and quality attribution by applying a "constrained autonomy" principle, implementing a six‑layer architecture, high‑concurrency optimizations, comprehensive observability, and layered quality gates to support hundreds of thousands of simultaneous creators.

AI video generationAgentic ArchitectureQuality Gatekeeping
0 likes · 12 min read
Constrained Autonomy: An Agentic Architecture Scaling to Hundreds of Thousands of Creators
Deepin Linux
Deepin Linux
Jun 22, 2026 · Backend Development

Memory Pool vs Object Pool: When to Choose and How to Build One from Scratch

The article explains why high‑concurrency programs suffer from memory fragmentation and system‑call overhead, compares memory pools and object pools, outlines their distinct use‑cases, provides step‑by‑step C and C++ implementations, and highlights optimization tips and common pitfalls.

C++Performance OptimizationThread Safety
0 likes · 20 min read
Memory Pool vs Object Pool: When to Choose and How to Build One from Scratch
Code Farming
Code Farming
Jun 20, 2026 · Backend Development

How This Architecture Handles Tens‑Fold Traffic Spikes Without Crashing

The article breaks down a complete flash‑sale system into four phases and explains how Redis distributed locks, CDN static pages, Nginx rate limiting, message‑queue peak shaving, and sharding together prevent overselling, crashes, and lost orders even when traffic surges dozens of times.

Message QueueNginxRedis
0 likes · 6 min read
How This Architecture Handles Tens‑Fold Traffic Spikes Without Crashing
Cloud Architecture
Cloud Architecture
Jun 20, 2026 · Backend Development

Beyond Nearby Users: Building a Millisecond‑Level Real‑Time Dispatch System with GeoHash and Spring Boot

This article dissects the architecture, algorithms, and production practices behind a millisecond‑level real‑time dispatch system that uses GeoHash for spatial indexing, Spring Boot for service orchestration, Redis GEO for fast candidate selection, and a series of scoring, atomic reservation, and observability techniques to handle millions of riders under high concurrency.

GeoHashRedis GeoSpring Boot
0 likes · 36 min read
Beyond Nearby Users: Building a Millisecond‑Level Real‑Time Dispatch System with GeoHash and Spring Boot
ZhiKe AI
ZhiKe AI
Jun 19, 2026 · Backend Development

From 1 ns to 10 ms: Why Caching Exists and Why It Keeps You Up at Night

The article explains why caching is indispensable—from nanosecond‑level CPU caches to millisecond‑level disks—covers the classic pitfalls of penetration, breakdown and avalanche, and walks through consistency strategies such as Cache‑Aside, delayed double‑delete, and Canal‑based binlog syncing for high‑concurrency systems.

Cache AsideCache ConsistencyCanal
0 likes · 13 min read
From 1 ns to 10 ms: Why Caching Exists and Why It Keeps You Up at Night
samdeepthink
samdeepthink
Jun 18, 2026 · Backend Development

Designing a Billion‑User Payment System: Final Architecture Review

This article reviews the end‑to‑end design of a payment platform that handles 500,000 daily orders, detailing the three‑layer gateway‑orchestration‑base architecture, independent channel services, reconciliation mechanisms, and how business constraints drive each architectural decision.

gatewayhigh concurrencymicroservices
0 likes · 15 min read
Designing a Billion‑User Payment System: Final Architecture Review
Architecture & Thinking
Architecture & Thinking
Jun 18, 2026 · Backend Development

How to Scale a Flash‑Sale System from Zero to 1 Million QPS: A Step‑by‑Step Architecture Guide

This article dissects the evolution of a flash‑sale system from a simple monolithic controller to a cloud‑native, micro‑service architecture that can handle over one million requests per second, detailing traffic‑shaping, multi‑level caching, async processing, and inventory‑consistency techniques.

KubernetesMessage QueueRedis
0 likes · 18 min read
How to Scale a Flash‑Sale System from Zero to 1 Million QPS: A Step‑by‑Step Architecture Guide
Subtle Storm
Subtle Storm
Jun 17, 2026 · Backend Development

What QPS Level Is Considered High Concurrency?

The article defines QPS, explains that high concurrency has no absolute threshold, and provides typical QPS ranges for various scenarios—from small internal systems to national‑scale apps—along with the architectural measures needed at each level.

Distributed SystemsQPSScaling
0 likes · 6 min read
What QPS Level Is Considered High Concurrency?
Cloud Architecture
Cloud Architecture
Jun 17, 2026 · Backend Development

Nginx Unified Gateway Deep Dive: Multi‑Domain, Dynamic Routing, and Ten‑Million Concurrency Load Balancing

This article analyses how Nginx evolves from a simple reverse proxy to a unified edge gateway, covering multi‑domain management, dynamic routing, high‑concurrency capacity planning, load‑balancing algorithms, TLS handling, observability, Kubernetes deployment, and practical production pitfalls.

KubernetesNginxOpenResty
0 likes · 35 min read
Nginx Unified Gateway Deep Dive: Multi‑Domain, Dynamic Routing, and Ten‑Million Concurrency Load Balancing
Subtle Storm
Subtle Storm
Jun 15, 2026 · Backend Development

Caching, Rate Limiting, Smoothing, and Idempotency: Solving Concurrency Problems

The article breaks down how caching reduces repeated slow‑resource access, rate limiting protects systems from overload, smoothing (peak shaving) buffers burst traffic with queues, and idempotency prevents duplicate operations, using a milk‑tea shop analogy to illustrate each technique’s role in high‑concurrency environments.

BackendIdempotencyPeak Shaving
0 likes · 7 min read
Caching, Rate Limiting, Smoothing, and Idempotency: Solving Concurrency Problems
Mike Chen's Internet Architecture
Mike Chen's Internet Architecture
Jun 15, 2026 · Operations

Designing Million‑QPS Architecture: LVS + Nginx + Keepalived Three‑Layer Load Balancing

The article explains how to build a million‑request‑per‑second system by combining LVS, Nginx, and Keepalived in a three‑layer load‑balancing architecture, detailing each layer’s responsibilities, configuration snippets, and kernel tuning parameters that ensure high throughput and seamless failover.

KeepalivedLVSNginx
0 likes · 5 min read
Designing Million‑QPS Architecture: LVS + Nginx + Keepalived Three‑Layer Load Balancing
Cloud Architecture
Cloud Architecture
Jun 12, 2026 · Backend Development

1 Million QPS Coupon‑Grab System: Distributed Rate Limiting, Stock Capping, and CAP Trade‑offs

The article explains how a production‑grade coupon‑grab service can survive millions of requests per second by treating rate limiting as a business admission layer, separating stock capping from throttling, making explicit CAP trade‑offs, and implementing a hybrid Redis‑based token‑bucket limiter with local fallback, monitoring, and deployment best practices.

CAP theoremCoupon SystemDistributed Systems
0 likes · 28 min read
1 Million QPS Coupon‑Grab System: Distributed Rate Limiting, Stock Capping, and CAP Trade‑offs
Cloud Architecture
Cloud Architecture
Jun 10, 2026 · Backend Development

How to End Duplicate Consumption in RocketMQ with Idempotence and High‑Concurrency Architecture

The article explains why RocketMQ inevitably delivers duplicate messages under at‑least‑once semantics, analyzes root causes in producer, broker and consumer stages, and presents a production‑grade idempotent solution that combines business keys, Redis caching, Redisson locks, a MySQL idempotent table, AOP interception, and comprehensive monitoring to guarantee exactly‑once business outcomes even under high concurrency and Kubernetes graceful shutdown.

Distributed SystemsIdempotenceJava
0 likes · 34 min read
How to End Duplicate Consumption in RocketMQ with Idempotence and High‑Concurrency Architecture
Cloud Architecture
Cloud Architecture
Jun 8, 2026 · Backend Development

Why Fixed‑Window Rate Limiting Fails in High‑Concurrency: Full Guide to Three Production‑Ready Approaches

The article explains why the simple fixed‑window counter is a hidden trap for high‑traffic systems, outlines five essential questions for production‑grade rate limiting, and compares three practical deployment patterns—single‑node Guava token bucket, Redis‑based distributed sliding window, and Sentinel‑driven microservice governance—complete with code and operational tips.

Distributed SystemsGuavaRedis
0 likes · 44 min read
Why Fixed‑Window Rate Limiting Fails in High‑Concurrency: Full Guide to Three Production‑Ready Approaches
Cloud Architecture
Cloud Architecture
Jun 5, 2026 · Backend Development

RocketMQ 4.x Deep Dive: Send Mechanics, Thread Model & High‑Concurrency

This article explains why a RocketMQ producer is more than a simple send API, detailing its role in system throughput, consistency and fault isolation, and walks through sending principles, thread models, high‑concurrency design, retry strategies, back‑pressure mechanisms, outbox integration and production‑grade monitoring.

JavaMessage QueueOutbox
0 likes · 54 min read
RocketMQ 4.x Deep Dive: Send Mechanics, Thread Model & High‑Concurrency