BestHub
Sign in
Tagged articles
756 articles
Page 1 of 8
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
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
Java Architect Handbook
Java Architect Handbook
Apr 28, 2026 · Backend Development

SpringBoot + Disruptor: Achieving 6 Million Orders per Second with Ultra‑Fast Concurrency

This article explains why Disruptor—a lock‑free, high‑throughput Java queue from LMAX—was chosen over traditional brokers, details its core concepts such as RingBuffer, Sequence, and WaitStrategy, and provides a step‑by‑step SpringBoot demo that can handle up to six million orders per second without pressure.

DisruptorJavaMessage Queue
0 likes · 13 min read
SpringBoot + Disruptor: Achieving 6 Million Orders per Second with Ultra‑Fast Concurrency
Architect Chen
Architect Chen
Apr 28, 2026 · Backend Development

How High Must TPS Be for a Payment System to Be Considered High‑Throughput?

The article analyzes why payment systems require far higher transactions‑per‑second than typical web apps, outlines the challenges of distributed transactions under high load, and classifies TPS levels—from 1,000 daily to over 300,000—as benchmarks, citing Alipay’s Double 11 peak as an ultra‑high example.

BackendDistributed TransactionsTPS
0 likes · 3 min read
How High Must TPS Be for a Payment System to Be Considered High‑Throughput?
dbaplus Community
dbaplus Community
Apr 25, 2026 · Backend Development

From Zero to One: Complete Architecture Design for a Billion‑Scale Short‑Video System

This article dissects the end‑to‑end architecture of a billion‑scale short‑video platform, detailing layered design, core services such as upload, transcoding, recommendation, interaction, storage, and the key challenges of massive video storage, high‑concurrency streaming, low‑latency playback, and real‑time recommendation reliability.

MicroservicesStorage OptimizationSystem Architecture
0 likes · 19 min read
From Zero to One: Complete Architecture Design for a Billion‑Scale Short‑Video System
Ray's Galactic Tech
Ray's Galactic Tech
Apr 24, 2026 · Backend Development

From Bottlenecks to a High‑Concurrency Medical Assistant with LangChain4j

This guide details how to design and implement a production‑grade, high‑concurrency medical AI assistant using LangChain4j, Spring Boot, Redis, and Kubernetes, covering architecture, RAG‑enhanced retrieval, controlled tool invocation, guardrails, idempotent transactions, scaling strategies and observability to ensure reliable, compliant patient interactions.

LangChain4jRAGSpring Boot
0 likes · 33 min read
From Bottlenecks to a High‑Concurrency Medical Assistant with LangChain4j
Ray's Galactic Tech
Ray's Galactic Tech
Apr 24, 2026 · Backend Development

Self‑Healing Agents: Rebuilding a High‑Concurrency Travel System with Spring AI ReAct

This article details how a legacy travel‑booking service was transformed into a production‑grade, self‑healing agent system using Spring AI ReAct and multi‑tool coordination, covering architectural redesign, tool governance, error semantics, high‑concurrency safeguards, observability, security, and real‑world performance gains.

AgentBackendReact
0 likes · 31 min read
Self‑Healing Agents: Rebuilding a High‑Concurrency Travel System with Spring AI ReAct
JD Tech
JD Tech
Apr 23, 2026 · Backend Development

How JD Upgraded Its B‑Side Order Storage Architecture to Tackle Elasticsearch High‑Concurrency Pressure

Facing explosive merchant growth and soaring order volumes, JD redesigned its B‑side POP order storage by isolating large tenants, applying double‑hash routing, expanding clusters, buffering updates, and automating data archiving, ultimately delivering a high‑performance, scalable Elasticsearch platform that sustains massive traffic spikes.

Backend ArchitectureData SkewElasticsearch
0 likes · 16 min read
How JD Upgraded Its B‑Side Order Storage Architecture to Tackle Elasticsearch High‑Concurrency Pressure
mikechen
mikechen
Apr 23, 2026 · Backend Development

How Nginx Handles One Million Concurrent Connections: 4 Key Techniques

The article explains how Nginx sustains one million simultaneous connections by using asynchronous non‑blocking I/O, a robust multi‑process architecture, zero‑copy file transmission, and optimized caching strategies, with concrete configuration examples and performance reasoning.

NGINXZero Copyasynchronous I/O
0 likes · 4 min read
How Nginx Handles One Million Concurrent Connections: 4 Key Techniques
Architect Chen
Architect Chen
Apr 23, 2026 · Databases

How Redis Handles 1 Million Concurrent Connections: 4 Key Techniques

Redis achieves million‑level concurrency by keeping all data in RAM, using epoll/kqueue for non‑blocking I/O, employing highly optimized data structures with O(1) or O(log N) operations, and evolving from a single‑threaded core to optional multi‑threaded I/O, boosting throughput up to 12×.

Data StructuresI/O MultiplexingIn-Memory
0 likes · 4 min read
How Redis Handles 1 Million Concurrent Connections: 4 Key Techniques
MaGe Linux Operations
MaGe Linux Operations
Apr 16, 2026 · Operations

Mastering Nginx for High‑Traffic: Proven Tuning Steps for 10k+ QPS

This guide explains why the default Nginx configuration becomes a bottleneck under thousands of requests per second and provides a prioritized, production‑tested checklist of kernel, process, buffer, upstream, HTTP, and HA settings to dramatically improve throughput and latency.

ConfigurationLinux kernelNGINX
0 likes · 24 min read
Mastering Nginx for High‑Traffic: Proven Tuning Steps for 10k+ QPS
Architect Chen
Architect Chen
Apr 16, 2026 · Operations

L4 vs L7 Load Balancing at Million‑Concurrency: Which Is More Stable?

The article compares Layer‑4 and Layer‑7 load‑balancing solutions for million‑concurrency scenarios, outlining their use cases, advantages, typical tools, performance characteristics, and why large enterprises often combine both to achieve high stability and flexible traffic control.

Backend ArchitectureL4L7
0 likes · 3 min read
L4 vs L7 Load Balancing at Million‑Concurrency: Which Is More Stable?
Architect Chen
Architect Chen
Apr 13, 2026 · Backend Development

How to Make Spring Cloud Gateway Handle a Million Concurrent Requests

This article explains how Spring Cloud Gateway leverages a reactive, non‑blocking architecture, OS‑level tuning, zero‑copy networking, and built‑in rate‑limiting and circuit‑breaker features to reliably sustain million‑level concurrent traffic in production environments.

NettySpring Cloud Gatewayhigh concurrency
0 likes · 4 min read
How to Make Spring Cloud Gateway Handle a Million Concurrent Requests
Ray's Galactic Tech
Ray's Galactic Tech
Apr 4, 2026 · Backend Development

How to Build a High‑Concurrency Story Creation Platform with AgentScope Java

This article presents a step‑by‑step engineering guide for constructing a production‑grade, high‑throughput story generation platform using AgentScope Java, Spring Boot, Kafka, Redis, PostgreSQL, and Kubernetes, covering architecture, task modeling, DAG orchestration, code organization, scalability, observability, and deployment best practices.

JavaKafkaMulti-Agent
0 likes · 39 min read
How to Build a High‑Concurrency Story Creation Platform with AgentScope Java
Ray's Galactic Tech
Ray's Galactic Tech
Apr 1, 2026 · Operations

High‑Availability Log Platform for Ten‑Million‑Level Concurrency

This article presents a comprehensive, production‑grade design for a log collection and analysis pipeline that can reliably handle ten‑million‑level concurrent writes by combining Filebeat, Redis, Logstash, and Elasticsearch with careful buffering, scaling, and observability strategies.

ELKFilebeatLogstash
0 likes · 32 min read
High‑Availability Log Platform for Ten‑Million‑Level Concurrency
Tech Freedom Circle
Tech Freedom Circle
Mar 25, 2026 · Backend Development

Cracking Alibaba’s 10M Orders Interview: Architecture Seven‑Suite + Heterogeneous Storage Solution

The article dissects Alibaba’s second‑round interview question on handling 10 million daily order queries, exposing why a single sharding answer fails and presenting a comprehensive architecture‑seven‑suite combined with heterogeneous storage (MySQL, HBase, ClickHouse, ES, Redis, MQ) to achieve high concurrency, low latency, and reliable data consistency.

Backend ArchitectureDistributed SystemsInterview Preparation
0 likes · 40 min read
Cracking Alibaba’s 10M Orders Interview: Architecture Seven‑Suite + Heterogeneous Storage Solution
IT Services Circle
IT Services Circle
Mar 11, 2026 · Backend Development

How to Build Scalable Python Back‑End Systems: Architecture, Async, and Ops

This article walks Python developers through designing high‑concurrency back‑end systems, covering architectural planning, modular project layout, async I/O with asyncio and FastAPI, load balancing with Gunicorn, database scaling, Celery task queues, caching, rate limiting, monitoring, and graceful shutdown techniques.

FastAPIPythonasyncio
0 likes · 20 min read
How to Build Scalable Python Back‑End Systems: Architecture, Async, and Ops
Top Architect
Top Architect
Mar 3, 2026 · Backend Development

How to Build a Million‑User Ticket‑Snatching System with Nginx, Redis, and Go

This article explains how to design a high‑concurrency ticket‑snatching service that can handle millions of requests by combining multi‑layer load balancing, weighted Nginx round‑robin, in‑memory stock with Redis‑backed global inventory, and Go’s native concurrency, complete with code samples and performance results.

GoNGINXRedis
0 likes · 19 min read
How to Build a Million‑User Ticket‑Snatching System with Nginx, Redis, and Go
Selected Java Interview Questions
Selected Java Interview Questions
Feb 26, 2026 · Backend Development

Why Your Snowflake‑Like ID Generator May Duplicate IDs Under High Concurrency

The article analyzes a custom TraceIdGenerator that uses a simple AtomicInteger counter and IP‑based prefix, identifying how its reset logic and CAS competition can cause duplicate IDs in high‑concurrency scenarios, and proposes timestamp checks, larger ranges, retry mechanisms, and true Snowflake implementation as solutions.

AtomicIntegerID generationJava
0 likes · 11 min read
Why Your Snowflake‑Like ID Generator May Duplicate IDs Under High Concurrency
ITPUB
ITPUB
Feb 22, 2026 · Backend Development

Designing a Cost‑Controlled “Cut‑One‑Knife” Promotion Engine for Massive Concurrency

This article breaks down the algorithm and architecture behind Pinduoduo's "cut‑one‑knife" promotion, explaining how dynamic pricing based on user value, Zeno’s paradox, Redis atomic operations, and anti‑fraud measures ensure users receive phones without the platform incurring losses even under massive traffic and bot attacks.

Zeno paradoxanti-frauddynamic pricing
0 likes · 8 min read
Designing a Cost‑Controlled “Cut‑One‑Knife” Promotion Engine for Massive Concurrency
Top Architect
Top Architect
Feb 18, 2026 · Backend Development

Building a Million‑User Ticket‑Spiking System with Nginx Load Balancing, Redis, and Go

This article explores how to design a high‑concurrency ticket‑spike service inspired by China’s 12306 platform, covering multi‑layer load balancing, local stock pre‑allocation, Redis‑based global inventory control, Go implementation details, and performance testing that demonstrates handling millions of simultaneous requests.

Redishigh concurrencyticketing system
0 likes · 21 min read
Building a Million‑User Ticket‑Spiking System with Nginx Load Balancing, Redis, and Go
Code Wrench
Code Wrench
Feb 7, 2026 · Backend Development

How Go’s Netpoller Powers Millions of Connections – 5 Real‑World Cases

This article explains why Go programs often fail to reach C10M concurrency, analyzes five real‑world incidents, reveals the inner workings of Go's netpoller, and provides concrete code‑level optimizations, configuration tweaks, and load‑testing practices to achieve stable million‑connection services.

GoNetwork programminghigh concurrency
0 likes · 23 min read
How Go’s Netpoller Powers Millions of Connections – 5 Real‑World Cases
Tencent Cloud Developer
Tencent Cloud Developer
Feb 4, 2026 · Backend Development

How We Cut Server Costs by 82%: Refactoring a High‑Concurrency QQ Game Service from C++ to Go with Kafka

This article details the redesign of a core QQ game achievement service that suffered from low resource utilization and heavy CAS contention, describing how moving from a synchronous C++ implementation to an asynchronous Go‑Kafka pipeline eliminated lock conflicts, reduced server count by 82%, and dramatically improved latency and stability.

Kafkahigh concurrencyrefactoring
0 likes · 11 min read
How We Cut Server Costs by 82%: Refactoring a High‑Concurrency QQ Game Service from C++ to Go with Kafka
Java Tech Enthusiast
Java Tech Enthusiast
Jan 24, 2026 · Backend Development

How to Keep Database and Redis Cache Consistent Under High Concurrency

This article examines the common data‑consistency challenges when writing to both a database and a Redis cache, evaluates four write‑order strategies, and presents the most reliable approach—writing to the database first then deleting the cache—along with retry mechanisms using scheduled jobs, message queues, and binlog listeners.

BinlogCache ConsistencyElastic-Job
0 likes · 17 min read
How to Keep Database and Redis Cache Consistent Under High Concurrency
ITPUB
ITPUB
Jan 21, 2026 · Interview Experience

How to Design a Billion‑User Real‑Time Step Leaderboard for Interviews

This article breaks down the interview‑level system design of a WeChat‑style step leaderboard that must support over a billion users, handling massive write spikes, low‑latency friend ranking queries, storage scaling, and relationship complexity with a three‑part architecture using MQ, Redis, and MySQL.

KafkaRedisSystem Design
0 likes · 8 min read
How to Design a Billion‑User Real‑Time Step Leaderboard for Interviews
Architect's Guide
Architect's Guide
Jan 21, 2026 · Backend Development

Designing a High‑Performance Flash Sale System: 7 Key Architecture Strategies

This article outlines a comprehensive backend architecture for flash‑sale (秒杀) systems, covering traffic control, Nginx and CDN setup, gateway rate‑limiting, Redis caching and distributed locks, message‑queue throttling, async order processing, hotspot isolation, and security measures to handle massive concurrent requests.

Captchaflash salehigh concurrency
0 likes · 12 min read
Designing a High‑Performance Flash Sale System: 7 Key Architecture Strategies
SpringMeng
SpringMeng
Jan 21, 2026 · Industry Insights

Why Most Developers Struggle to Become Software Architects

Most programmers never become software architects because the role demands a distinct architectural mindset, extensive real‑world experience, and opportunities that are scarce in small teams, leading to a low proportion of architects and a career bottleneck for many engineers.

Career DevelopmentSoftware Architectureexperience gap
0 likes · 5 min read
Why Most Developers Struggle to Become Software Architects
Su San Talks Tech
Su San Talks Tech
Jan 20, 2026 · Databases

How to Ensure Data Consistency Between Database and Cache in High‑Concurrency Scenarios

This article examines the common data‑consistency problems that arise when updating both a database and a cache under high concurrency, evaluates four typical write‑order strategies, and presents the most reliable solution—writing to the database first and then safely invalidating the cache using retry, scheduled tasks, MQ, or binlog listeners.

ConsistencyMQRetry
0 likes · 17 min read
How to Ensure Data Consistency Between Database and Cache in High‑Concurrency Scenarios
Architect Chen
Architect Chen
Jan 18, 2026 · Backend Development

Mastering Million-Request Concurrency with Nginx, LVS, and Keepalived

This guide explains how to achieve million‑level concurrent request handling by combining Nginx, LVS, and Keepalived, detailing the architecture layers, load‑balancing design, high‑availability configuration, and practical sample configurations for each component in modern large‑scale web services.

LVSNGINXarchitecture
0 likes · 4 min read
Mastering Million-Request Concurrency with Nginx, LVS, and Keepalived
Mike Chen's Internet Architecture
Mike Chen's Internet Architecture
Jan 16, 2026 · Backend Development

Why Bigger Connection Pools Fail Under High Concurrency and What to Do Instead

Increasing a database connection pool size often worsens performance under massive traffic because the bottleneck lies in hardware limits and management overhead, so developers must adopt async processing, read‑write splitting, caching, sharding, and proper pool tuning to sustain high concurrency.

Backend PerformanceConnection Poolasynchronous processing
0 likes · 4 min read
Why Bigger Connection Pools Fail Under High Concurrency and What to Do Instead
Tech Freedom Circle
Tech Freedom Circle
Jan 16, 2026 · Interview Experience

Crack JD Interview: Master Singleton, Factory, Strategy, Template & Observer Patterns in 20 Minutes

This article offers a systematic, high‑concurrency‑focused walkthrough of core Java design patterns—including Singleton, Factory, Strategy, Template Method, and Observer—complete with code examples, pros and cons, selection guidelines, and interview‑ready explanations to help candidates impress interviewers and secure offers.

Design PatternsFactoryJava
0 likes · 36 min read
Crack JD Interview: Master Singleton, Factory, Strategy, Template & Observer Patterns in 20 Minutes
ITFLY8 Architecture Home
ITFLY8 Architecture Home
Jan 14, 2026 · Backend Development

How to Handle Hot Account Deduction in High‑Concurrency Systems

This article examines strategies for low‑latency, consistent hot‑account updates under high concurrency, comparing optimistic DB locking, Redis‑based deduction with asynchronous merging, data sharding, and MQ‑driven batch processing, and also addresses read‑side solutions.

Redisasynchronous processinghigh concurrency
0 likes · 5 min read
How to Handle Hot Account Deduction in High‑Concurrency Systems
Raymond Ops
Raymond Ops
Jan 6, 2026 · Operations

How to Boost Nginx to Over 1 Million QPS: Real‑World Optimization Guide

This guide walks you through a complete Nginx high‑concurrency tuning process—from basic worker and TCP settings to kernel parameters, caching, SSL, and advanced techniques like DPDK and JIT—showing performance improvements from 80 k to over a million QPS with real‑world examples and scripts.

LinuxNGINXWeb server
0 likes · 13 min read
How to Boost Nginx to Over 1 Million QPS: Real‑World Optimization Guide
Mike Chen's Internet Architecture
Mike Chen's Internet Architecture
Jan 2, 2026 · Backend Development

Implementing High‑Concurrency Circuit Breaking in Nginx with Lua

This guide explains how to use Nginx and OpenResty Lua scripts to implement rate limiting and circuit‑breaking for high‑concurrency services, detecting error rates and response latency, automatically opening and closing a 30‑second break window, and returning custom JSON responses when downstream services fail.

Circuit BreakingLuaNGINX
0 likes · 5 min read
Implementing High‑Concurrency Circuit Breaking in Nginx with Lua
Ops Community
Ops Community
Dec 28, 2025 · Artificial Intelligence

Boost LLM Inference Speed: Build a High‑Concurrency vLLM Service with Best‑Practice Ops

This guide walks through the complete process of deploying a high‑throughput large language model inference service using vLLM, covering environment preparation, installation, configuration tuning, performance testing, real‑world case studies, monitoring, troubleshooting, and backup strategies for production‑grade deployments.

DeploymentGPU OptimizationLLM inference
0 likes · 44 min read
Boost LLM Inference Speed: Build a High‑Concurrency vLLM Service with Best‑Practice Ops
DeWu Technology
DeWu Technology
Dec 15, 2025 · Backend Development

How Go Powers High‑Concurrency, High‑Availability Systems: 5 Real‑World Scenarios

This article explores five typical high‑concurrency, high‑availability scenarios—gRPC microservice communication, real‑time WebSocket messaging, API‑gateway rate limiting and circuit breaking, Redis‑Stream task queues, and Redis RedLock distributed locks—detailing the problems, Go‑centric solutions, code implementations, and supporting theory.

GoWebSocketgRPC
0 likes · 47 min read
How Go Powers High‑Concurrency, High‑Availability Systems: 5 Real‑World Scenarios
Mike Chen's Internet Architecture
Mike Chen's Internet Architecture
Dec 9, 2025 · Backend Development

Boost Kafka to Over 1 Million Messages per Second: Metrics and Tuning Tips

This article explains what high concurrency means for Kafka, outlines key performance metrics such as QPS, TPS, throughput and latency, and provides concrete configuration and architectural techniques—including broker optimization, horizontal scaling, network batching, and zero‑copy—to achieve write rates exceeding one million records per second.

BackendDistributed SystemsKafka
0 likes · 4 min read
Boost Kafka to Over 1 Million Messages per Second: Metrics and Tuning Tips
Architecture & Thinking
Architecture & Thinking
Dec 8, 2025 · Backend Development

Master Flash Sale Systems: Backend Strategies for Millions of Requests

This article explains the unique challenges of flash‑sale systems—massive, short‑lived traffic spikes—and presents practical backend optimizations such as front‑end request filtering, Redis‑based atomic counters, streaming queues, safe database updates, and unit‑level isolation for global deployments.

RedisSystem Designatomic operations
0 likes · 8 min read
Master Flash Sale Systems: Backend Strategies for Millions of Requests
Architect's Journey
Architect's Journey
Dec 5, 2025 · Backend Development

Capacity‑Driven Microservice Architecture: Solving High‑Concurrency Challenges

The article explains how a capacity‑driven microservice architecture uses performance metrics like QPS, TPS, and latency as the primary split criterion, detailing design principles, module responsibilities, and practical benefits that enable systems to handle traffic spikes without service collapse.

Domain-Driven DesignMicroservicescapacity‑driven architecture
0 likes · 10 min read
Capacity‑Driven Microservice Architecture: Solving High‑Concurrency Challenges
Architect's Journey
Architect's Journey
Dec 1, 2025 · Backend Development

Designing Three‑High Systems: Practical Performance Tuning and Fault‑Tolerant Architecture

The article breaks down the design logic and implementation steps for high‑performance, high‑concurrency, and high‑availability systems, covering bottleneck identification, read/write optimization, three‑dimensional scaling, and concrete fault‑tolerance strategies to build resilient, scalable services.

System Architecturefault tolerancehigh availability
0 likes · 15 min read
Designing Three‑High Systems: Practical Performance Tuning and Fault‑Tolerant Architecture
Tech Freedom Circle
Tech Freedom Circle
Nov 15, 2025 · Databases

How to Prevent Order Loss in a 100k TPS Flash Sale When the Master DB Crashes – 5 Practical Solutions

The article dissects a high‑traffic flash‑sale interview question—how to guarantee zero order loss at 100,000 TPS when the master MySQL instance fails—by explaining the underlying performance‑consistency conflict, the three skills interviewers assess, and presenting five concrete, code‑driven solutions ranging from MySQL parameter tuning to semi‑sync replication, local message tables, group replication, and Redis‑Kafka traffic shaping.

Data ConsistencyGroup ReplicationKafka
0 likes · 28 min read
How to Prevent Order Loss in a 100k TPS Flash Sale When the Master DB Crashes – 5 Practical Solutions
Ray's Galactic Tech
Ray's Galactic Tech
Nov 14, 2025 · Operations

Mastering Nginx Under High Load: Practical Tuning & Troubleshooting Guide

Learn how to identify and resolve common high‑concurrency bottlenecks for Nginx by optimizing OS limits, network stack, Nginx configuration, logging, reverse‑proxy settings, backend services, and hardware resources, with concrete commands, parameter values, and step‑by‑step troubleshooting procedures.

BackendOperationsSystem optimization
0 likes · 6 min read
Mastering Nginx Under High Load: Practical Tuning & Troubleshooting Guide
Mike Chen's Internet Architecture
Mike Chen's Internet Architecture
Nov 13, 2025 · Backend Development

Designing High‑Concurrency Microservice Architectures: Splitting, Sharding, Rate Limiting, and Circuit Breaking

This guide explains how to build a million‑request‑per‑second microservice system by properly splitting business domains, partitioning data with vertical and horizontal sharding, applying robust rate‑limiting techniques, and implementing circuit‑breaking and degradation strategies to maintain stability.

Circuit BreakingService Splittinghigh concurrency
0 likes · 6 min read
Designing High‑Concurrency Microservice Architectures: Splitting, Sharding, Rate Limiting, and Circuit Breaking
IT Services Circle
IT Services Circle
Nov 11, 2025 · Backend Development

How to Build a High‑Concurrency, Strong‑Consistency E‑Commerce Order System

An e‑commerce order system acts as the core connector linking users, merchants, payments, logistics and revenue, and this article dissects its three essential flows—forward, reverse and state transitions—while detailing the technical challenges and solutions for order creation, payment, fulfillment, cancellation, after‑sale, architecture, and data handling.

Distributed Systemse‑commercehigh concurrency
0 likes · 19 min read
How to Build a High‑Concurrency, Strong‑Consistency E‑Commerce Order System
Mike Chen's Internet Architecture
Mike Chen's Internet Architecture
Nov 6, 2025 · Cloud Native

How Spring Cloud Gateway Handles Millions of Concurrent Requests

Spring Cloud Gateway achieves ultra‑high concurrency through asynchronous non‑blocking I/O, minimal Netty event‑loop threads, horizontal scaling with load balancers, Redis‑based distributed rate limiting, and built‑in circuit‑breaker protection, ensuring stable performance even under massive traffic spikes.

MicroservicesSpring Cloud Gatewaycircuit breaker
0 likes · 4 min read
How Spring Cloud Gateway Handles Millions of Concurrent Requests
NiuNiu MaTe
NiuNiu MaTe
Nov 5, 2025 · Backend Development

How to Build a High‑Concurrency, Strong‑Consistency E‑Commerce Order System

This article dissects the core processes, functional challenges, and architectural design of a high‑throughput, strongly consistent e‑commerce order system, covering forward and reverse flows, order creation, payment, fulfillment, cancellation, after‑sale handling, and the layered backend architecture that powers it.

Backend ArchitectureDistributed SystemsMicroservices
0 likes · 21 min read
How to Build a High‑Concurrency, Strong‑Consistency E‑Commerce Order System
Mike Chen's Internet Architecture
Mike Chen's Internet Architecture
Oct 29, 2025 · Backend Development

Designing a Million‑Concurrent Backend: LVS, Nginx, and Spring Cloud Gateway

This article explains how to build a high‑performance, million‑concurrent backend architecture by combining LVS for L4 load balancing, Nginx for L7 routing, and Spring Cloud Gateway as a resilient microservice gateway, covering traffic distribution, gateway responsibilities, and fault‑tolerance mechanisms.

LVSMicroservicesgateway
0 likes · 6 min read
Designing a Million‑Concurrent Backend: LVS, Nginx, and Spring Cloud Gateway
Tech Freedom Circle
Tech Freedom Circle
Oct 29, 2025 · Backend Development

Combining RocketMQ Transaction Messages, Local Message Table, and XXL‑Job for 10‑100k QPS Distributed Transactions

This article presents a detailed design for a high‑concurrency (10‑100k QPS) distributed transaction solution that integrates RocketMQ transactional messages, an eBay‑style local message table, and XXL‑Job reconciliation to achieve eventual consistency while handling failures, retries, and data‑explosion challenges.

CAP theoremJavaLocal Message Table
0 likes · 34 min read
Combining RocketMQ Transaction Messages, Local Message Table, and XXL‑Job for 10‑100k QPS Distributed Transactions
Xiao Liu Lab
Xiao Liu Lab
Oct 27, 2025 · Operations

Boost Nginx to 100k+ Concurrent Connections: Essential Linux Kernel Tweaks

This guide explains why the default Linux kernel limits hinder Nginx performance, lists eight crucial sysctl parameters to increase port ranges, file descriptors, and connection queues, and shows how to verify and safely apply the changes for high‑concurrency workloads.

Linux kernelhigh concurrencynetwork optimization
0 likes · 7 min read
Boost Nginx to 100k+ Concurrent Connections: Essential Linux Kernel Tweaks
Raymond Ops
Raymond Ops
Oct 27, 2025 · Operations

Master Linux Network Tuning for High-Concurrency: Practical Guide

This guide walks through a real‑world high‑concurrency Linux scenario, diagnosing TCP state bottlenecks, analyzing default kernel parameters, and providing step‑by‑step sysctl tweaks, queue and buffer adjustments, monitoring scripts, and stress‑test recommendations to dramatically improve connection handling and throughput.

LinuxNetwork TuningPerformance Optimization
0 likes · 9 min read
Master Linux Network Tuning for High-Concurrency: Practical Guide
Tech Freedom Circle
Tech Freedom Circle
Oct 25, 2025 · Databases

Designing a 10 WQPS Redis Counter Component: A Systematic Timer Solution

This article presents a complete, step‑by‑step analysis of a high‑concurrency Redis counter component that supports up to 100 000 QPS, covering business pain points, architectural design, two core counting strategies, sharding, local batch optimization, code walkthroughs, and performance benchmark results.

CounterRedisSliding Window
0 likes · 33 min read
Designing a 10 WQPS Redis Counter Component: A Systematic Timer Solution
NiuNiu MaTe
NiuNiu MaTe
Oct 22, 2025 · Backend Development

How to Build a Lightning‑Fast, Stable Seckill System That Handles Millions of Requests

Learn how to design a robust, high‑performance seckill architecture that can endure millions of concurrent requests by breaking down business flow, defining precise technical metrics, and implementing a four‑layer system—access, traffic‑shaping, business logic, and data—using CDN, APISIX, Redis, RocketMQ, and MySQL with detailed code examples.

RocketMQSeckillSystem Architecture
0 likes · 22 min read
How to Build a Lightning‑Fast, Stable Seckill System That Handles Millions of Requests
Tech Freedom Circle
Tech Freedom Circle
Oct 20, 2025 · Backend Development

Mastering JVM Tuning: Real-World Enterprise Case Study for Interview Success

The article walks through a high‑traffic video service that suffered GC spikes, details a systematic diagnosis of three JVM configuration flaws, evaluates four GC tuning schemes across load scenarios, resolves CMS‑related pauses, and presents concrete performance gains with metrics, code snippets, and visual charts.

CMSGC tuningJVM
0 likes · 28 min read
Mastering JVM Tuning: Real-World Enterprise Case Study for Interview Success
Liangxu Linux
Liangxu Linux
Oct 19, 2025 · Operations

Boost Linux Server Throughput: Practical TCP/IP Stack Tuning Guide

This article presents a comprehensive, step‑by‑step guide for Linux network performance optimization, covering real‑world issues, sysctl parameter tweaks for TCP and IP stacks, queue and interrupt tuning, high‑concurrency strategies, monitoring scripts, a detailed e‑commerce case study, best‑practice recommendations, and safety precautions.

BBRLinuxTCP Tuning
0 likes · 13 min read
Boost Linux Server Throughput: Practical TCP/IP Stack Tuning Guide
dbaplus Community
dbaplus Community
Oct 16, 2025 · Backend Development

How to Build a Billion‑Scale Open Platform: Architecture, Caching, and Resilience

This article presents a step‑by‑step engineering guide for designing, evolving, and operating a high‑traffic open platform, covering three‑layer decoupled architecture, multi‑level caching, asynchronous message queues, distributed transaction models, high‑availability strategies, and phased rollout plans to sustain billions of daily API calls.

Distributed SystemsOpen Platformcaching
0 likes · 20 min read
How to Build a Billion‑Scale Open Platform: Architecture, Caching, and Resilience
Architecture Digest
Architecture Digest
Oct 8, 2025 · Backend Development

How Ticketing Platforms Handle Millions of Clicks Without Crashing

This article explains how modern ticketing systems achieve millisecond‑level response times under massive concurrent demand by combining client‑side defenses, API‑gateway signature verification, Redis atomic stock decrement, and message‑queue buffering, ensuring fairness, preventing bots, and protecting backend services from overload.

App SecurityMessage Queuehigh concurrency
0 likes · 10 min read
How Ticketing Platforms Handle Millions of Clicks Without Crashing
Architect
Architect
Oct 6, 2025 · Backend Development

Designing a High‑Performance Flash‑Sale System: Architecture & Best Practices

The article details a comprehensive flash‑sale system architecture covering seven key dimensions—including front‑end separation, Nginx gateway, Redis caching, MQ clustering, business logic, database sharding, and security measures—to achieve ultra‑high concurrency, low latency, and reliable order processing.

System Architectureflash salehigh concurrency
0 likes · 12 min read
Designing a High‑Performance Flash‑Sale System: Architecture & Best Practices
Architect's Guide
Architect's Guide
Oct 1, 2025 · Backend Development

How to Build High‑Traffic, High‑Concurrency Systems: Key Principles & Practices

Designing high‑traffic, high‑concurrency systems requires careful planning across architecture, client optimization, CDN usage, clustering, caching, database tuning, and service governance, with principles such as statelessness, modularity, and fault‑tolerance to ensure scalability, reliability, and maintainability.

Backend ArchitectureSystem Designcaching
0 likes · 12 min read
How to Build High‑Traffic, High‑Concurrency Systems: Key Principles & Practices
Su San Talks Tech
Su San Talks Tech
Sep 30, 2025 · Operations

Master High-Concurrency Nginx: Proven Configs to Crush 502/504 Errors

Learn how to transform Nginx into a high‑concurrency powerhouse by addressing common 502/504 errors, optimizing worker processes, event and HTTP settings, fine‑tuning OS kernel parameters, implementing caching, rate‑limiting, load‑balancing, and monitoring scripts, with practical code examples and checklists.

LinuxNGINXSystem optimization
0 likes · 10 min read
Master High-Concurrency Nginx: Proven Configs to Crush 502/504 Errors
dbaplus Community
dbaplus Community
Sep 27, 2025 · Backend Development

How to Build a Billion‑User Real‑Time Step Leaderboard Like WeChat Sports

Designing a real‑time step leaderboard for billions of users requires tackling massive write spikes, fast friend‑based queries, scalable storage, and high availability; this guide outlines a three‑step architecture using asynchronous message queues, Redis ZSETs, and MySQL sharding to meet those challenges.

Message QueueSystem Designhigh concurrency
0 likes · 7 min read
How to Build a Billion‑User Real‑Time Step Leaderboard Like WeChat Sports
NiuNiu MaTe
NiuNiu MaTe
Sep 24, 2025 · Backend Development

How to Build a Fast, Reliable, and Cost‑Effective Like System

This article breaks down the design of a high‑traffic like service, detailing four core requirements—speed, accuracy, stability, and cost control—while recommending Redis, a message queue, and MySQL, and illustrating the full architecture from frontend to persistence with practical code examples and optimization tips.

Message QueueSystem Designhigh concurrency
0 likes · 17 min read
How to Build a Fast, Reliable, and Cost‑Effective Like System
Tech Freedom Circle
Tech Freedom Circle
Sep 24, 2025 · Backend Development

Designing a US Presidential Election Voting System: 1M TPS, 10M QPS, Immutable and Non‑Duplicate Votes

This article presents a comprehensive architectural design for a high‑throughput US presidential voting platform that must handle 1 million transactions per second and 10 million queries per second while guaranteeing vote immutability, one‑person‑one‑vote enforcement, real‑time result aggregation, and scalable storage using microservices, Kafka, Redis, Bloom filters, and blockchain anchoring.

BlockchainBloom FilterDistributed Systems
0 likes · 32 min read
Designing a US Presidential Election Voting System: 1M TPS, 10M QPS, Immutable and Non‑Duplicate Votes
Sanyou's Java Diary
Sanyou's Java Diary
Sep 22, 2025 · Backend Development

How to Build a Scalable Enterprise Unified Message Push System

This article explains why growing enterprises need a unified message‑push platform, outlines the core challenges such as multi‑channel integration, high concurrency, reliability, templating and extensibility, and then walks through a complete architecture design—including access, business, service and storage layers—to achieve a scalable, maintainable solution.

BackendEnterpriseMessage Push
0 likes · 10 min read
How to Build a Scalable Enterprise Unified Message Push System
Su San Talks Tech
Su San Talks Tech
Sep 18, 2025 · Backend Development

Designing a Million‑QPS Rate Limiter for Backend System Interviews

This article walks through a complete, interview‑ready design of a high‑performance rate‑limiting system that can handle up to one million queries per second, covering requirements, core entities, algorithm choices, distributed state storage with Redis, scalability, high availability, latency optimization, hot‑key mitigation, and dynamic rule configuration.

Backend ArchitectureDistributed SystemsSystem Design
0 likes · 29 min read
Designing a Million‑QPS Rate Limiter for Backend System Interviews
Architect's Guide
Architect's Guide
Sep 17, 2025 · Backend Development

How to Build a High‑Performance Flash‑Sale System: 7 Key Architecture Strategies

This article explains the characteristics of flash‑sale traffic and presents a comprehensive backend architecture—including Nginx static separation, Redis caching and locking, MQ buffering, rate‑limiting, async order processing, database sharding, captcha protection, and page optimization—to handle massive concurrent requests while ensuring security and reliability.

NGINXSystem Architectureflash sale
0 likes · 11 min read
How to Build a High‑Performance Flash‑Sale System: 7 Key Architecture Strategies
Su San Talks Tech
Su San Talks Tech
Sep 15, 2025 · Backend Development

How to Build a Scalable Food Delivery System: Architecture, High Concurrency, and Real‑Time Dispatch

This article dissects the architecture of a high‑traffic food‑delivery platform, covering layered micro‑service design, core service implementations, smart dispatch algorithms, real‑time rider tracking, peak‑time scaling strategies, and practical solutions to common performance and reliability challenges.

BackendMicroservicesfood delivery
0 likes · 18 min read
How to Build a Scalable Food Delivery System: Architecture, High Concurrency, and Real‑Time Dispatch
Su San Talks Tech
Su San Talks Tech
Sep 11, 2025 · Databases

Why Redis Handles Millions of Requests: Deep Dive into Its High‑Performance Architecture

This article explains how Redis achieves ultra‑high concurrency by combining a single‑threaded event‑driven core, highly optimized in‑memory data structures, efficient I/O multiplexing, smart memory management, asynchronous persistence, and scalable clustering, allowing it to comfortably serve hundreds of thousands of simultaneous requests.

Event-drivenMemory OptimizationPersistence
0 likes · 16 min read
Why Redis Handles Millions of Requests: Deep Dive into Its High‑Performance Architecture
Open Source Tech Hub
Open Source Tech Hub
Sep 10, 2025 · Backend Development

Build High‑Performance PHP RPC Services with Workerman‑JsonRpc

This guide introduces Workerman‑JsonRpc, a lightweight PHP RPC framework built on Workerman, detailing its key features, environment requirements, installation steps, synchronous and asynchronous client usage, server implementation, and built‑in monitoring capabilities for creating scalable network applications.

BackendJSON-RPCPHP
0 likes · 7 min read
Build High‑Performance PHP RPC Services with Workerman‑JsonRpc
Su San Talks Tech
Su San Talks Tech
Sep 8, 2025 · Backend Development

Why Online Payments Stall at Peak Hours and How Modern Backend Design Fixes It

This article dissects the architecture of modern online payment systems, explaining how layered, distributed designs handle millions of requests per second, ensure data consistency, prevent fraud, and recover from failures through robust routing, locking, reconciliation, and disaster‑recovery strategies.

Data ConsistencySecurityhigh concurrency
0 likes · 18 min read
Why Online Payments Stall at Peak Hours and How Modern Backend Design Fixes It
Architect
Architect
Sep 6, 2025 · Operations

Master High-Concurrency Nginx: Core Configs, Advanced Tuning, and Real-World Checklist

This guide walks you through the common high‑traffic pain points of Nginx, explains why configuration and tuning matter more than hardware, and provides step‑by‑step core, advanced, OS‑level, monitoring, and troubleshooting configurations to reliably handle tens of thousands of concurrent connections.

LinuxNGINXServer Configuration
0 likes · 11 min read
Master High-Concurrency Nginx: Core Configs, Advanced Tuning, and Real-World Checklist
Architect Chen
Architect Chen
Sep 4, 2025 · Backend Development

How Nginx Achieves High Concurrency with Event‑Driven and Non‑Blocking I/O

This article explains Nginx's event‑driven architecture, asynchronous non‑blocking I/O, and master‑worker multi‑process model, showing how these techniques eliminate waiting, maximize resource utilization, and enable the server to handle massive concurrent connections efficiently.

BackendEvent-drivenNGINX
0 likes · 4 min read
How Nginx Achieves High Concurrency with Event‑Driven and Non‑Blocking I/O
Su San Talks Tech
Su San Talks Tech
Sep 1, 2025 · Backend Development

Build a Scalable Short‑Video System: Architecture, Storage, and Real‑Time Recommendations

This article dissects the architecture of a modern short‑video backend, covering layered system design, core services such as video production, distribution, interaction, storage strategies, real‑time and offline recommendation engines, high‑concurrency streaming solutions, and practical techniques for cost control, scalability, and fault tolerance.

Backend ArchitectureStorage Optimizationhigh concurrency
0 likes · 22 min read
Build a Scalable Short‑Video System: Architecture, Storage, and Real‑Time Recommendations
Su San Talks Tech
Su San Talks Tech
Aug 25, 2025 · Backend Development

How to Build a High‑Concurrency Queue System with OpenResty, Lua, and Redis

This article analyzes current system performance bottlenecks, compares hard‑rate‑limiting and flexible queuing strategies, and presents a non‑intrusive traffic‑control solution built with OpenResty+Lua and Redis that offers zero‑code changes, high performance, scalability, and real‑time visual feedback for high‑concurrency scenarios.

LuaOpenRestyRedis
0 likes · 18 min read
How to Build a High‑Concurrency Queue System with OpenResty, Lua, and Redis