Tagged articles
high QPS
45 articles · Page 1 of 1
This article details the evolution of cache reconstruction strategies for ten-million-QPS systems, covering cold-start dangers, persistence recovery limits, tiered hot-data backfill, dual-cluster hot standby for second-level failover, shard-level background rebuild with singleflight, and multi-layer database protection during rebuilds, advocating making pre-warming a routine capability.
Cache Warmingcache reconstructioncold start
0 likes · 27 min read

This article traces the evolution of data recovery from manual backup restoration through log replay to automated replica switching, explaining RPO/RTO trade-offs, and details how 10M QPS systems implement shard-level automatic rebuild with throttling, verification, and continuous recovery as a runtime capability.
RPORTOReplication
0 likes · 20 min read

This article details a complete control-loop design for automatic fault isolation in 10M QPS systems, covering evidence-based detection, capacity-aware action planning, guardrails, phased rollout from shadow mode to autonomy, and evaluation metrics for speed, correctness, and safety.
Control LoopFault IsolationSRE
0 likes · 41 min read

When a production outage forces a midnight investigation across five services, the lack of log standards turns a quick debug into an all‑night forensic hunt; the article explains how structured logs, a unified schema, level semantics, trace_id linking, and field‑level masking enforced by SDK, Lint and CI can eliminate these five walls and make logging scalable, searchable, and compliant.
CI enforcementhigh QPSlog masking
0 likes · 22 min read

At ten‑million QPS, log data can explode from a few gigabytes to terabytes or even petabytes, triggering storage blow‑up, pipeline saturation, slow queries, runaway costs, and poor signal‑to‑noise, and the article breaks down ingest, index, and store costs while presenting edge sampling, label‑based indexing, tiered storage, and log‑to‑metric rollup as mitigation tactics.
Cost OptimizationElasticsearchLogging
0 likes · 19 min read

The article explains how moving feature switches from hard‑coded if‑else statements to a platform‑based runtime system enables granular targeting, gradual rollouts, A/B experiments, instant kill‑switches, and SDK‑based local evaluation that can handle millions of queries per second without redeployments.
A/B testingKill SwitchSDK local evaluation
0 likes · 17 min read

The article explains how large‑scale, million‑QPS systems transition from hard‑coded file configurations to centralized, dynamically pushed config centers, detailing the problems of file‑based configs, the benefits of externalization, dynamic updates, governance features, and the trade‑offs involved.
ApolloConfiguration ManagementDynamic Configuration
0 likes · 20 min read

The article explains how a shared thread pool can turn a localized slowdown into a system‑wide outage, then walks through the bulkhead isolation pattern, bounded queues, trade‑offs between thread‑pool and semaphore isolation, sizing formulas, monitoring metrics, and dynamic tuning for high‑QPS services.
Concurrencybulkhead patterndynamic thread pool
0 likes · 16 min read

The article walks through a real‑world order system that spikes to 300,000 QPS, explaining why the original single‑node MySQL design fails, and detailing a step‑by‑step evolution—index tuning, transaction fixes, read‑write splitting, vertical and horizontal sharding, plus data‑pipeline integration—to achieve stable low latency at massive scale.
Index OptimizationMySQLPerformance Tuning
0 likes · 20 min read

Scaling a service from millions to tens of millions of queries per second fails not because of data size but due to per‑request fixed costs, and the article shows how batching aggregates these costs, dramatically boosts throughput, reduces latency, and introduces new challenges such as memory pressure and partial failures.
batch processinghigh QPSlatency tradeoff
0 likes · 17 min read

The article explains how moving non‑critical actions in a high‑traffic e‑commerce order flow to a task queue separates core work from optional work, solving delivery guarantees, idempotency, backlog management, and ordering challenges while dramatically reducing latency and fault contagion.
Asynchronous ProcessingIdempotencyTask Queue
0 likes · 17 min read

The article explains how a naïve ‘retry three times’ default can amplify a minor 200 ms latency spike into a full‑scale outage in a 10 million‑QPS system, and walks through a progressive design—from identifying retry‑eligible transient faults, adding exponential backoff with jitter, enforcing idempotency, applying token‑bucket retry budgets, integrating circuit breakers, to using hedged requests—showing how each layer prevents traffic amplification and ensures reliable high‑throughput services.
Circuit BreakerIdempotencyJitter
0 likes · 18 min read

A 3‑second fixed timeout turned an 800 ms latency spike in a recommendation service into a full‑site outage, illustrating how static timeouts can exhaust thread pools; the article walks through evolving from global timeouts to per‑interface limits, deadline propagation, and coordinated timeout‑retry‑circuit‑breaker strategies for resilient 10 M‑QPS systems.
Circuit BreakerRPCRetry
0 likes · 15 min read

A flame‑graph reveals that in high‑throughput services only about 30% of CPU time is spent on business logic while the rest is consumed by serialization, prompting a step‑by‑step evolution from flexible JSON to compact binary formats, zero‑copy techniques, and selective compression to keep costs under control at tens of millions of requests per second.
FlatBuffersJSONProtobuf
0 likes · 15 min read

A midnight alert revealed latency jumping from 20 ms to 200 ms despite healthy CPU and memory, leading to an investigation that uncovered TCP connection handling—handshake delays, TIME_WAIT buildup, and CPU overhead—as the hidden bottleneck, and explains why short connections must evolve into pooled, globally managed connections at tens of millions of QPS.
Connection ManagementTCPconnection pool
0 likes · 18 min read

When a single generic endpoint that returns over thirty fields is stressed at ten‑million queries per second, it becomes the weakest link, exposing costs of over‑fetching, downstream amplification, cache inefficiency and coupling; the article dissects these issues and shows how specialized APIs, BFF layers, and GraphQL can address them, while weighing their trade‑offs.
API DesignBFFGraphQL
0 likes · 18 min read

A tiny field‑addition and rename in an order service caused a cascade failure in a three‑year‑old reconciliation job, illustrating how any incompatible change in a system handling tens of millions of QPS can trigger an avalanche, and the article explains why version management, compatible design, multi‑version coexistence, and disciplined governance are essential to keep such large‑scale services reliable.
API versioningService Governancecompatible design
0 likes · 18 min read

An unexpected restart of an edge user‑tag service caused a core transaction chain to fail, exposing how reverse and circular dependencies can turn a clean layered architecture into a tangled web; the article explains the hidden costs of such chaos and outlines two hard rules and a step‑by‑step path to enforce strict, acyclic layering for systems handling tens of millions of QPS.
Circular DependencyLayered Architecturedependency-governance
0 likes · 15 min read

When a high‑traffic system processes billions of messages per day, stale “zombie” messages can corrupt business state; this article walks through the evolution from never‑expiring queues to uniform TTL, then per‑topic and per‑message TTL, and finally to smart, context‑aware expiration, detailing the engineering trade‑offs, implementation patterns, and operational checklist needed for reliable 10 M‑QPS message pipelines.
KafkaMessage QueueRocketMQ
0 likes · 19 min read

The article dissects how to handle massive message backlog in ten‑million‑QPS systems, explaining why simply adding consumer machines fails, and walks through six evolutionary stages—from manual scaling and auto‑scaling to traffic tiering, consumer‑side optimizations, dynamic strategies, and AI‑driven intelligent scheduling—while highlighting design trade‑offs, pitfalls, and practical tooling.
Auto ScalingMessage QueueOperations
0 likes · 22 min read

At 10 million QPS, message backlog can silently grow for hours, turning minutes of lag into hundreds of millions of undelivered messages; this article walks through a six‑stage evolution—from manual command‑line checks to SLO‑driven predictive monitoring—detailing metrics, pitfalls, and tool choices for a robust, multi‑dimensional alert system.
KafkaSLOalerting
0 likes · 21 min read

The article examines why cross‑datacenter replication must evolve from simple asynchronous copying to semi‑synchronous and layered strategies at the ten‑million‑QPS scale, detailing latency, RPO, bandwidth costs, failover complexities, and practical selection guidelines for each business tier.
FailoverMessage Queueasynchronous replication
0 likes · 17 min read

Message queues guarantee at‑least‑once delivery, making duplicate messages a normal feature; the article examines a real coupon‑distribution incident, critiques business‑level idempotency approaches, and outlines a layered platform‑wide middleware design—including unique keys, state machines, storage choices, and TTL strategies—to achieve reliable processing at ten‑million QPS scale.
IdempotencyMessage Queuedistributed systems
0 likes · 19 min read

High‑concurrency systems must go beyond simple locking; the article breaks down four progressive strategies—optimistic locking, database pessimistic locking, Redis distributed locks, and finally message‑queue serialization—explaining their trade‑offs, implementation details, pitfalls, and how to combine them into a layered architecture that sustains million‑QPS workloads with consistency, throughput, and recoverability.
Message QueueOptimistic LockRedis Lock
0 likes · 32 min read

A real‑world rack‑power outage showed that three‑replica Kafka clusters can lose all replicas when brokers share a failure domain, prompting a deep dive into rack awareness—how fault‑domain tags are injected, replica‑placement and leader‑distribution algorithms, consumer‑proximity reads, bandwidth costs, failure scenarios, and the stepwise evolution from hundred‑thousand to ten‑million QPS deployments.
KafkaPulsarRack Awareness
0 likes · 26 min read

In ultra‑high‑throughput systems, dead‑letter handling must evolve from a basic discard queue to a comprehensive lifecycle that includes monitoring, attribution, replay, archiving, and dashboards, turning failure messages into actionable system health assets.
Dead Letter QueueKafkaRetry
0 likes · 19 min read

The article dissects why message loss is an end‑to‑end engineering challenge across production, broker, and consumer stages, presents real‑world failure cases at ten‑million QPS, and outlines concrete strategies—ack loops, outbox tables, broker replication settings, consumer handling rules, observability, reconciliation, and SLA‑driven compensation—to evolve from best‑effort to provable, recoverable reliability.
Message QueueOutbox PatternSLA
0 likes · 17 min read

The article explains why consumer‑side rate limiting is essential in million‑QPS systems, detailing how unchecked consumers can overwhelm downstream services, and presents practical strategies—including pause/resume, token‑bucket algorithms, adaptive thresholds, and global coordination—to safely throttle consumption without dropping messages.
KafkaMessage Queueconsumer optimization
0 likes · 16 min read

A midnight bandwidth alarm triggers a deep dive into message compression, revealing how algorithm choice, compression placement, batch handling, and selective policies evolve from simple no‑compression setups to multi‑layered strategies that balance CPU, bandwidth, disk costs, and latency in million‑QPS systems.
KafkaZstdbatch compression
0 likes · 20 min read

The article explains why partition count is not a simple integer but the solution of a multi‑constraint capacity‑planning equation, walks through three design stages—from naïve defaults, through CPU‑core‑based heuristics, to a precise engineering model that balances throughput, ordering, scaling, fault domains and storage costs for million‑plus QPS workloads.
Consistent HashingKafkaPartition Design
0 likes · 32 min read

This guide walks through practical techniques to push MySQL performance from a few thousand to tens of millions of queries per second, covering single‑node tuning, read/write splitting, caching layers, and horizontal/vertical sharding with concrete configuration tips and architecture diagrams.
CachingMySQLSharding
0 likes · 4 min read

This article explains why a million‑QPS flood can cripple systems, outlines attackers' tactics, and presents a three‑layer defense strategy—including gateway rate limiting with Nginx + Lua, distributed circuit breaking via Sentinel, device fingerprinting, behavior analysis, and a dynamic rule engine—to protect high‑traffic services.
DDoSbehavior analysishigh QPS
0 likes · 14 min read

The article presents the Universal Recommendation Model (URM), a large‑language‑model‑based recall framework that integrates world knowledge and e‑commerce expertise through knowledge injection and prompt‑driven alignment, achieving significant offline recall gains and a 3.1% increase in ad consumption while meeting high‑QPS, low‑latency production constraints.
AdvertisingRecallhigh QPS
0 likes · 17 min read

RTAMS‑GANNS, the award‑winning real‑time adaptive multi‑stream GPU system for online approximate nearest neighbor search, eliminates costly memory allocations and serial execution by using a dynamic memory‑block insertion algorithm and separate CUDA streams, cutting latency by 40‑80% and reliably serving over 100 million daily users in production.
Approximate Nearest NeighborGPUVector Insertion
0 likes · 19 min read

This article summarizes the challenges and optimization techniques for building a high‑performance long‑connection service with Netty, covering non‑blocking I/O, Linux kernel tuning, client‑side testing, VM‑based scaling, data‑structure tweaks, CPU and GC bottlenecks, and the final results of achieving hundreds of thousands of connections and tens of thousands of QPS on a single server.
GC tuningJava NIOLinux tuning
0 likes · 14 min read

This article explores how naive timestamp retrieval can become a CPU bottleneck under high concurrency, demonstrates cache‑based optimizations used in Alibaba's Cobar and Sentinel projects, presents benchmark results, and proposes an adaptive algorithm to enable or disable caching based on real‑time QPS.
Javahigh QPStimestamp caching
0 likes · 11 min read

The Xianyu fan‑tag system solves the challenge of displaying full‑history purchase counts with real‑time updates and low‑latency, high‑throughput queries by daily exporting multi‑system data to a LevelDB‑based KV store, converting schemas, and applying real‑time compensation from transaction and follow‑change messages, merging offline and live data to produce sorted fan lists at ~10 k QPS.
KV storagedata aggregationhigh QPS
0 likes · 6 min read


ByteFEApr 11, 2022 · Backend Development
This article details ByteDance's wallet asset middle platform designed for the 2022 Spring Festival, covering eight‑app reward interoperability, high‑QPS challenges, token‑based asynchronous入账, budget control, stability measures, and fund‑safety guarantees, and includes practical solutions for hot‑key handling, budget throttling, and multi‑stage activity isolation.
ByteDanceFund SafetyToken Scheme
0 likes · 22 min read

This article details a step‑by‑step engineering experiment that reproduces a high‑throughput "red‑envelope" service, outlining the required hardware, software stack, load‑generation logic, monitoring setup, and performance results for handling up to 6 000 QPS on a 100‑million‑user scale.
BackendGodistributed systems
0 likes · 21 min read

This article details a step‑by‑step engineering effort to model and benchmark a high‑throughput red‑packet service capable of handling 10 billion requests, covering target metrics, hardware setup, Go implementation, load generation, monitoring, and performance analysis.
GoLoad Simulationbackend architecture
0 likes · 22 min read

This article describes how to design, implement, and evaluate a scalable backend that can simulate 10 billion WeChat red‑envelope requests by supporting up to 1 million concurrent users and handling 30 k–60 k QPS per server using Go, Linux tools, and custom monitoring.
GoSimulationbackend architecture
0 likes · 18 min read

The article describes how a Go‑based high‑throughput service was tuned from 80k to over 200k QPS by enlarging the GC heap, reusing UDP connections with sync.Pool, reducing system‑call overhead, and applying several lightweight logging and discovery optimizations.
GC tuningGoUDP
0 likes · 8 min read

This article explains the concept of soft‑start in performance testing, presents Java implementations for both fixed‑thread and fixed‑QPS models, discusses error‑impact considerations, and provides practical code snippets to gradually ramp up load and improve measurement accuracy for high‑throughput services.
ConcurrencyJavahigh QPS
0 likes · 8 min read

This article describes a backend architecture for a high‑traffic e‑commerce project, detailing a cache access component and a cache update platform that use asynchronous messaging, hotspot‑key handling, versioned cache entries, and Redis to achieve low latency, high QPS support and strong data consistency.
BackendCachingdistributed-systems
0 likes · 18 min read

Meituan’s DSP system boosted high‑QPS ad serving performance by layering an LRU cache in front of Redis, then adding time‑based eviction, sharding the cache into HashLruCache instances to cut lock contention, and employing a zero‑copy, reference‑counted design, ultimately cutting average latency to about 20 % of the original and similarly reducing 99.9th‑percentile delays.
HashLruCacheLRUCacheMeituan DSP
0 likes · 15 min read
