BestHub
Sign in
Tagged articles

high concurrency

885 articles · Page 1 of 9
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.

Rediscache protectiondistributed lock
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 agentsCircuit BreakerConcurrency Budget
0 likes · 18 min read
How AI Agents Handle High Concurrency: Admission, Backpressure, Async & Isolation
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 LawLoad Testing
0 likes · 17 min read
Spring Boot Tomcat Tuning: Breaking the 4K QPS Ceiling with Thread Pool & Keep-Alive Config
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.

Backend DevelopmentCPU OptimizationCoding Best Practices
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.

Operationsautomationblameless culture
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.

PaxosStoreRedisSystem Design
0 likes · 18 min read
How WeChat Resets 1 Billion Step Counts at Midnight Without Crashing
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.

NettyProtocol DesignTCP
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.

auto-repairbalance-validationdistributed systems
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.

Domain-Driven DesignMicroservicesOutbox Pattern
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.

Outboxhigh concurrencyidempotency
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.

Outbox Patternbalance snapshotdouble-entry accounting
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.

RedisTPSe-commerce
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.

JVMMicroservicesThread Pool
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.

LuaRedisdistributed systems
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.

NginxPerformancehigh concurrency
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.

Cachingbackend designfeed 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.

DisruptorPerformanceSpringBoot
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.

CDNHDFSSystem Design
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.

Disruptorhigh concurrencyjava
0 likes · 10 min read
Spring Boot + Disruptor: Achieving Ultra‑Fast High‑Concurrency Processing for 6 Million Orders per Second
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.

Nginxhigh concurrencylinux limits
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 Gatewayevent-drivenhigh concurrency
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.

Circuit BreakingKafkaRedis
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
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.

System Designconsistent hashingdistributed cache
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.

NginxPerformanceQPS
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.

LuaMQRedis
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.

DDDMicroservicesPayment 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.

System Designasynchronous-processingdecoupling
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 RAGCachingKnowledge 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.

Optimistic LockRedis PersistenceSpring StateMachine
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.

MicroservicesMySQLSnowflake
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.

KafkaKubernetesMQTT
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 OptimizationThread Pool
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 BreakerSystem Design
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.

AlipayOutboxWeChat Pay
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.

Redis optimizationcounter architecturehigh concurrency
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.

Cachingdatabase optimizatione-commerce
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.

KafkaMicroservicesMongoDB
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.

ElasticsearchMySQLOutbox
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.

Device AccessEvent StreamingIoT
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.

SnowflakeUUIDdistributed-id
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 OperationsMicroservicesRBAC
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 theoremCachingHigh Performance
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.

Index OptimizationInnoDBMySQL
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.

KafkaObservabilityOutbox
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.

ObservabilitySpringBootWeChat Pay
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 FilterMicroservicesNegative Cache
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.

Lua scriptingMemory OptimizationRedis
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.

DubboKubernetesMicroservices
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.

high concurrencykernel parameterslinux sysctl
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 ArchitectureObservability
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.

NginxRedisflash sale
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.

GeoHashMicroservicesObservability
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.

CachingCanalRedis
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.

Microservicesgatewayhigh concurrency
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.

CachingDistributed ArchitectureKubernetes
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.

QPSdistributed systemshigh concurrency
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.

KubernetesNginxObservability
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.

BackendCachingPeak 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 theoremKubernetesRedis
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.

IdempotenceRedisRocketMQ
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.

GuavaRedisSentinel
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.

OutboxRocketMQhigh concurrency
0 likes · 54 min read
RocketMQ 4.x Deep Dive: Send Mechanics, Thread Model & High‑Concurrency
Cloud Architecture
Cloud Architecture
Jun 4, 2026 · Databases

PostgreSQL vs MySQL: The Ultimate Engineering Guide to Database Selection

This comprehensive guide compares PostgreSQL and MySQL from an engineering perspective, covering business models, transaction semantics, concurrency, replication, scalability, operational costs, real‑world case studies, and a decision matrix to help teams choose the database that minimizes long‑term complexity and cost.

MySQLOutbox PatternPostgreSQL
0 likes · 38 min read
PostgreSQL vs MySQL: The Ultimate Engineering Guide to Database Selection
Architect Chen
Architect Chen
Jun 3, 2026 · Fundamentals

What TPS Threshold Defines High Concurrency? A Complete Guide

The article explains TPS (Transactions Per Second), shows how to calculate it with a concrete example, and outlines industry‑based concurrency tiers—from less than 100 TPS for ordinary systems up to 50,000+ TPS for billion‑level traffic platforms—helping readers understand what counts as high concurrency.

System ThroughputTPShigh concurrency
0 likes · 3 min read
What TPS Threshold Defines High Concurrency? A Complete Guide
Cloud Architecture
Cloud Architecture
Jun 2, 2026 · Databases

Advanced MySQL Production Practices: From Kernel Principles to High‑Concurrency Implementation

This guide presents a production‑grade MySQL playbook for senior developers, architects, and DB engineers, covering kernel internals, architecture governance, connection‑pool sizing, InnoDB tuning, index design, transaction and lock handling, replication, sharding, distributed transactions, change management, observability, security, cloud‑native deployment, and a complete best‑practice checklist.

Index OptimizationInnoDBMySQL
0 likes · 42 min read
Advanced MySQL Production Practices: From Kernel Principles to High‑Concurrency Implementation
Subtle Storm
Subtle Storm
May 27, 2026 · Cloud Native

Designing High-Concurrency Systems: Lessons from a Sports Venue Management Platform

The article analyzes a real-world sports‑venue management platform, detailing how multi‑level caching, asynchronous processing with RocketMQ, database sharding, service splitting, and Kubernetes auto‑scaling together reduced average response time from 1200 ms to 150 ms, increased throughput eightfold, and achieved 99.95% availability under tens of thousands of QPS.

CachingKubernetesMicroservices
0 likes · 13 min read
Designing High-Concurrency Systems: Lessons from a Sports Venue Management Platform
Subtle Storm
Subtle Storm
May 26, 2026 · Cloud Native

Structuring a High-Concurrency System Design Paper for the 2026 Soft Exam

The article outlines a step‑by‑step framework for writing a high‑concurrency system design paper, covering project background, performance challenges, six concrete technical solutions—including multi‑level caching, async processing, rate limiting, database optimization, microservice decomposition, and elastic scaling—and how to quantify their impact with real data.

CachingKubernetesMicroservices
0 likes · 6 min read
Structuring a High-Concurrency System Design Paper for the 2026 Soft Exam
Lobster Programming
Lobster Programming
May 25, 2026 · Backend Development

Designing a System That Can Survive Sudden Spikes of One Million QPS

The article analyzes why simply adding Redis nodes cannot handle a sudden million‑QPS surge, then presents three practical solutions—key sharding, multi‑level caching with hot‑key detection, and distributed‑lock‑based fallback—to build a resilient high‑concurrency backend.

Cache ShardingCircuit BreakerHot Key Detection
0 likes · 7 min read
Designing a System That Can Survive Sudden Spikes of One Million QPS
Xiaolin Talks Programming
Xiaolin Talks Programming
May 21, 2026 · Backend Development

High-Performance QPS Monitoring in Spring Boot: Sliding Window, RingBuffer & LongAdder Deep Dive

This article details a production-ready QPS monitoring implementation for Spring Boot using sliding window algorithm with RingBuffer and LongAdder for high-concurrency safety, integrated with Micrometer for metrics exposure, covering algorithm design, code implementation, performance optimization, and distributed monitoring strategies.

Distributed MonitoringLongAdderMicrometer
0 likes · 19 min read
High-Performance QPS Monitoring in Spring Boot: Sliding Window, RingBuffer & LongAdder Deep Dive
AI Agent Super App
AI Agent Super App
May 20, 2026 · Operations

Enterprise‑Grade Nginx Configuration: From Binary Install to High‑Concurrency Production Deployment

This guide walks through installing Nginx via package manager or source compilation, explains core roles, provides a production‑ready configuration template, and details reverse proxy, load‑balancing strategies, health checks, high‑concurrency tuning, and HTTPS setup with self‑signed and Let’s Encrypt certificates.

LinuxNginxSSL
0 likes · 13 min read
Enterprise‑Grade Nginx Configuration: From Binary Install to High‑Concurrency Production Deployment
Cloud Architecture
Cloud Architecture
May 17, 2026 · Backend Development

Production Design for Order Timeout Closure: RabbitMQ Delay Queues, Idempotent State Machine

This article presents a production‑grade architecture for automatically closing unpaid orders, detailing why simple scheduled tasks are insufficient, outlining high‑risk scenarios, defining five core objectives, comparing implementation options, and providing a complete RabbitMQ TTL + DLX solution with state‑machine idempotency, high‑concurrency handling, observability, and Kubernetes deployment guidance.

RabbitMQdistributed systemshigh concurrency
0 likes · 40 min read
Production Design for Order Timeout Closure: RabbitMQ Delay Queues, Idempotent State Machine
samdeepthink
samdeepthink
May 17, 2026 · Backend Development

Final Episode: Building a Million‑Concurrent Product System

This article reviews the complete C‑end product system built for billions of users, covering demand analysis, Java migration, high‑concurrency read service design, launch safeguards, and a detailed list of proven caching and traffic‑isolation techniques validated in production.

CachingEAV modelJava migration
0 likes · 9 min read
Final Episode: Building a Million‑Concurrent Product System
Cloud Architecture
Cloud Architecture
May 12, 2026 · Information Security

High-Concurrency Phone Encryption: Blind Index, KMS Management & Rotation

This article presents a production‑grade solution for encrypting phone numbers in high‑concurrency microservices, combining random AES‑GCM ciphertext with HMAC‑based blind indexes, multi‑version KMS‑managed keys, zero‑downtime key rotation, and detailed component designs to ensure confidentiality, exact searchability, and operational stability.

Database SecurityKey Managementblind-index
0 likes · 40 min read
High-Concurrency Phone Encryption: Blind Index, KMS Management & Rotation
Deepin Linux
Deepin Linux
May 12, 2026 · Backend Development

From Zero to One: Mastering Linux NAPI High‑Concurrency Packet Reception

This article explains why traditional interrupt‑driven network I/O stalls under high traffic, introduces the NAPI (New API) mechanism that combines interrupt wake‑up with batch polling, details its core data structures and scheduling functions, and provides step‑by‑step configuration and tuning guidance to achieve efficient, low‑latency packet processing on Linux servers.

KernelLinuxNAPI
0 likes · 35 min read
From Zero to One: Mastering Linux NAPI High‑Concurrency Packet Reception
Cloud Architecture
Cloud Architecture
May 9, 2026 · Backend Development

High‑Concurrency Flash‑Sale Blueprint: Redis Atomic Stock and Kafka Throttling

The article presents a production‑grade, scalable flash‑sale architecture that combines Redis atomic inventory deduction, Kafka asynchronous peak‑shaving, and careful database finalization, detailing each layer’s goals, pre‑filtering techniques, Lua scripting, idempotency, capacity planning, monitoring, and compensation strategies to prevent overselling and ensure reliability.

KafkaRedisdistributed systems
0 likes · 31 min read
High‑Concurrency Flash‑Sale Blueprint: Redis Atomic Stock and Kafka Throttling
Cloud Architecture
Cloud Architecture
May 6, 2026 · Backend Development

Why Polling Breaks at Scale and How Spring Boot Webhooks Enable High‑Concurrency Event‑Driven Architecture

The article explains why traditional polling becomes unsustainable under high load, contrasts polling with webhook‑based event delivery, and provides a complete Spring Boot implementation—including outbox pattern, Kafka integration, retry logic, security, observability, and operational best practices—to build a production‑grade, scalable webhook platform.

KafkaObservabilityOutbox
0 likes · 36 min read
Why Polling Breaks at Scale and How Spring Boot Webhooks Enable High‑Concurrency Event‑Driven Architecture
AI Explorer
AI Explorer
May 2, 2026 · Backend Development

Building a High‑Concurrency DeepSeek Middleware with Go

The ds2api project, written in Go, offers a high‑concurrency, plugin‑based middleware that standardizes and converts various AI model APIs into DeepSeek‑compatible requests, delivering tens of thousands of conversions per second with millisecond latency and a simple three‑step setup.

AI InfrastructureDeepSeekGo
0 likes · 6 min read
Building a High‑Concurrency DeepSeek Middleware with Go
Cloud Architecture
Cloud Architecture
May 1, 2026 · Backend Development

Production Nginx for 10M+ QPS: Rate Limiting, Load Balancing, WebSocket, gRPC, CDN

This guide details how to build a production‑grade Nginx edge layer capable of handling over ten million queries per second, covering traffic shaping, connection reuse, multi‑level caching, sophisticated rate‑limiting, load‑balancing algorithms, WebSocket and gRPC handling, dynamic configuration, observability, container deployment, and migration paths to API gateways or service meshes.

CachingKubernetesNginx
0 likes · 52 min read
Production Nginx for 10M+ QPS: Rate Limiting, Load Balancing, WebSocket, gRPC, CDN