BestHub
Sign in
Tagged articles
575 articles
Page 5 of 6
Spring Full-Stack Practical Cases
Spring Full-Stack Practical Cases
Aug 6, 2021 · Backend Development

Spring Cloud Gateway Guide: Discovery, Hystrix, Custom Filters & Rate Limiting

This article demonstrates how to configure Spring Cloud Gateway with service discovery, two routing methods, integrate Hystrix for circuit breaking, implement global and custom token filters, and apply Redis‑based rate limiting, providing complete code snippets and configuration examples for a robust backend microservice architecture.

Custom FiltersHystrixSpring Cloud
0 likes · 10 min read
Spring Cloud Gateway Guide: Discovery, Hystrix, Custom Filters & Rate Limiting
Programmer DD
Programmer DD
Jul 31, 2021 · Backend Development

Mastering API Design: Standards, Practices, and Real‑World Guidelines

This comprehensive guide explains why clear API specifications are essential, compares RESTful and RPC styles, outlines OpenAPI and Google design principles, and provides practical rules for versioning, URL design, HTTP methods, status codes, authentication, rate limiting, error handling, naming conventions, and documentation to help developers build robust, maintainable services.

Error HandlingHTTP methodsOpenAPI
0 likes · 25 min read
Mastering API Design: Standards, Practices, and Real‑World Guidelines
Su San Talks Tech
Su San Talks Tech
Jul 29, 2021 · Backend Development

How to Build a High‑Performance Flash Sale System: 9 Essential Design Tips

Designing a flash‑sale (秒杀) system for massive concurrent users requires careful handling of instant traffic spikes, page staticization, CDN acceleration, caching strategies, distributed locks, rate limiting, asynchronous processing, and reliable stock management, with nine detailed techniques to ensure stability and prevent overselling.

backend-developmentcachingdistributed-lock
0 likes · 26 min read
How to Build a High‑Performance Flash Sale System: 9 Essential Design Tips
Java Interview Crash Guide
Java Interview Crash Guide
Jul 24, 2021 · Backend Development

Mastering Rate Limiting in Go: Algorithms, Implementations, and Best Practices

This article explains why rate limiting is essential for high‑availability services, describes HTTP 429 standards and response headers, classifies rate‑limiting strategies by granularity, target, and algorithm, and provides detailed Go code examples using the time/rate library for fixed‑window, sliding‑window, leaky‑bucket, and token‑bucket implementations.

BackendGoToken Bucket
0 likes · 28 min read
Mastering Rate Limiting in Go: Algorithms, Implementations, and Best Practices
21CTO
21CTO
Jul 16, 2021 · Operations

What Bilibili’s Outage Teaches About Achieving True High Availability

The article analyzes Bilibili’s recent service outage, explains why high availability matters, introduces key metrics like MTBF and MTTR, and outlines practical strategies such as redundancy, rate limiting, isolation, failover, timeout control, circuit breaking, degradation, and multi‑region deployment to build resilient systems.

MTBFMTTROperations
0 likes · 18 min read
What Bilibili’s Outage Teaches About Achieving True High Availability
ITFLY8 Architecture Home
ITFLY8 Architecture Home
Jul 15, 2021 · Backend Development

How Our Reactive API Gateway Powers Microservices: Architecture & Features

This article details the design and implementation of a reactive API gateway built on RxNetty, covering its overall architecture, request dispatch, conditional routing for gray releases, API management, rate limiting, circuit breaking, security policies, and integrated monitoring and tracing capabilities.

BackendMicroservicesrate limiting
0 likes · 13 min read
How Our Reactive API Gateway Powers Microservices: Architecture & Features
Wukong Talks Architecture
Wukong Talks Architecture
Jul 14, 2021 · Operations

Understanding High Availability: Lessons from the Bilibili Outage

This article analyzes Bilibili's recent service disruption, explains the concept and quantitative metrics of high availability, and outlines practical techniques such as rate limiting, isolation, failover, timeout control, circuit breaking, degradation, and multi‑region active‑active deployments to improve system reliability.

Distributed SystemsHAMTBF
0 likes · 13 min read
Understanding High Availability: Lessons from the Bilibili Outage
Architect
Architect
Jul 9, 2021 · Backend Development

Designing a High‑Concurrency Flash Sale System: Architecture, Caching, Rate Limiting, and Isolation Strategies

This article explains how to design a flash‑sale (秒杀) system that can handle massive traffic spikes by using static page CDN caching, gateway request interception, Redis inventory control, asynchronous order processing, and thorough business, deployment, and data isolation to ensure high performance and stability without affecting regular services.

CDNSystem Architecturebackend design
0 likes · 10 min read
Designing a High‑Concurrency Flash Sale System: Architecture, Caching, Rate Limiting, and Isolation Strategies
Top Architect
Top Architect
Jul 7, 2021 · Backend Development

Design and Implementation of a High‑Concurrency API Gateway

This article details the architecture and implementation of a high‑concurrency API gateway built on RxNetty, covering request routing, conditional routing, API management, rate limiting, circuit breaking, security policies, monitoring, tracing, and future enhancements within a microservices environment.

Microservicesapi-gatewaybackend-development
0 likes · 11 min read
Design and Implementation of a High‑Concurrency API Gateway
MaGe Linux Operations
MaGe Linux Operations
Jul 3, 2021 · Backend Development

How to Build a Go Log Collector with etcd, Context, and Kafka Integration

This article walks through redesigning a Go‑based log‑collection framework, introducing etcd for distributed configuration, demonstrating context for timeout and data propagation, and showing how to integrate Kafka consumers while improving concurrency handling and adding rate‑limiting mechanisms.

BackendKafkacontext
0 likes · 16 min read
How to Build a Go Log Collector with etcd, Context, and Kafka Integration
iQIYI Technical Product Team
iQIYI Technical Product Team
Jun 18, 2021 · Frontend Development

Improving Nuxt SSR Stability for iQIYI Frontend: Performance, Caching, Rate Limiting, Disaster Recovery, and Logging

To boost iQIYI’s front‑end reliability, the team replaced a Velocity‑based SSR with Nuxt, introduced a centralized page‑config plugin, streamlined legacy‑browser handling, built a visual data‑filtering API, implemented Nginx and component caching, purge endpoints, multi‑layer rate limiting, disaster‑recovery fallback, and comprehensive logging, achieving ~0.5 s first‑screen loads, 0.2 % error rate and near‑100 % availability.

NuxtSSRlogging
0 likes · 19 min read
Improving Nuxt SSR Stability for iQIYI Frontend: Performance, Caching, Rate Limiting, Disaster Recovery, and Logging
Full-Stack Internet Architecture
Full-Stack Internet Architecture
Jun 15, 2021 · Backend Development

Understanding Rate Limiting: Counter, Sliding Window, Leaky Bucket, and Token Bucket Algorithms

The article introduces the concept of rate limiting, explains why it is needed both offline (e.g., crowded theme parks) and online (e.g., flash sales), and details four common algorithms—counter, sliding window, leaky bucket, and token bucket—along with their implementation considerations and trade‑offs.

Sliding WindowToken Bucketcounter algorithm
0 likes · 9 min read
Understanding Rate Limiting: Counter, Sliding Window, Leaky Bucket, and Token Bucket Algorithms
ITPUB
ITPUB
Jun 15, 2021 · Backend Development

How to Build a High‑Performance Flash‑Sale System: Architecture, CDN, and Rate‑Limiting Strategies

This article explains how to design a flash‑sale (秒杀) system that handles massive concurrent traffic by staticizing product pages, using CDN pre‑heat, applying gateway rate‑limiting and segmented request release, leveraging Redis and asynchronous queues for inventory and order processing, and isolating services to protect normal business.

e‑commerceflash salehigh concurrency
0 likes · 11 min read
How to Build a High‑Performance Flash‑Sale System: Architecture, CDN, and Rate‑Limiting Strategies
IT Architects Alliance
IT Architects Alliance
Jun 13, 2021 · Backend Development

API Gateway: Concepts, Functional and Non‑Functional Requirements

This article explains the concept of an API Gateway, its essential functional requirements such as routing, load balancing, service aggregation, authentication, rate limiting, caching, and retries, and outlines the key non‑functional requirements including security, performance, high availability, scalability, and monitoring for microservice architectures.

rate limiting
0 likes · 15 min read
API Gateway: Concepts, Functional and Non‑Functional Requirements
ITFLY8 Architecture Home
ITFLY8 Architecture Home
Jun 12, 2021 · Backend Development

Designing a High‑Performance Microservice API Gateway: Routing, Load Balancing, and Resilience

This article outlines a comprehensive design for a microservice API gateway, covering functional aspects such as routing, load‑balancing algorithms, service aggregation, authentication, traffic control, circuit breaking, and caching, as well as non‑functional concerns like high performance, high availability, scalability, statelessness, and monitoring.

AuthenticationMicroservicesapi-gateway
0 likes · 15 min read
Designing a High‑Performance Microservice API Gateway: Routing, Load Balancing, and Resilience
Spring Full-Stack Practical Cases
Spring Full-Stack Practical Cases
Jun 9, 2021 · Cloud Native

Spring Cloud Gateway Guide: Discovery, Hystrix, Filters & Rate Limiting

This tutorial demonstrates how to configure Spring Cloud Gateway with service discovery, integrate Hystrix for circuit breaking, implement global and custom route filters, and apply Redis-based rate limiting, providing complete Maven dependencies, Java code examples, and YAML configurations for a robust microservice gateway.

Custom FilterHystrixSpring Cloud
0 likes · 11 min read
Spring Cloud Gateway Guide: Discovery, Hystrix, Filters & Rate Limiting
Programmer DD
Programmer DD
Jun 4, 2021 · Operations

Mastering Fault‑Tolerant Microservices: Patterns for Reliable Distributed Systems

This article explores essential patterns and techniques—such as graceful degradation, change management, health checks, failover caching, retry logic, rate limiting, circuit breakers, and chaos testing—to build highly available microservice architectures that can withstand network, hardware, and application failures.

Cloud Nativecircuit breakerfault tolerance
0 likes · 15 min read
Mastering Fault‑Tolerant Microservices: Patterns for Reliable Distributed Systems
Ops Development Stories
Ops Development Stories
May 25, 2021 · Backend Development

Master Rate Limiting: Counter, Sliding Window, Leaky & Token Bucket Algorithms

This article introduces common rate‑limiting algorithms—counter, sliding‑window, leaky bucket, and token bucket—explains their principles, compares their advantages and drawbacks, and provides Java code examples, including how Sentinel 1.8.0 implements each technique using structures such as LeapArray and WarmUpController.

algorithmjavarate limiting
0 likes · 17 min read
Master Rate Limiting: Counter, Sliding Window, Leaky & Token Bucket Algorithms
dbaplus Community
dbaplus Community
May 20, 2021 · Backend Development

Mastering API Gateways with Spring Cloud Gateway: Routing, Rate Limiting, and Dynamic Configuration

This article explains the purpose and principles of API gateways in microservice architectures, introduces Spring Cloud Gateway's core concepts and workflow, and provides step‑by‑step examples for basic routing, weighted routing, rate limiting, and dynamic route management with complete code snippets.

Dynamic ConfigurationMicroservicesSpring Cloud Gateway
0 likes · 19 min read
Mastering API Gateways with Spring Cloud Gateway: Routing, Rate Limiting, and Dynamic Configuration
Full-Stack Internet Architecture
Full-Stack Internet Architecture
May 20, 2021 · Backend Development

Designing a High‑Concurrency Flash‑Sale (秒杀) System: From Naïve Implementation to Optimized Solutions

This article walks through the design of a flash‑sale system, starting with a simple SpringBoot‑MyBatis implementation, then addressing overselling with pessimistic and optimistic locks, applying rate‑limiting algorithms, time‑window controls, interface hiding, frequency limits, and a suite of production‑grade optimizations such as CDN, Nginx load balancing, Redis caching, message queues, and short‑URL handling.

SpringBootflash saleoptimistic lock
0 likes · 14 min read
Designing a High‑Concurrency Flash‑Sale (秒杀) System: From Naïve Implementation to Optimized Solutions
360 Smart Cloud
360 Smart Cloud
Apr 30, 2021 · Backend Development

Understanding Rate Limiting: Concepts, Architectures, Algorithms, and a Redis‑Lua Token Bucket Implementation

This article explains what rate limiting is, why it is needed, the typical actions taken when limits are reached, compares single‑node and distributed architectures, reviews four classic limiting algorithms, and provides a practical Redis‑Lua token‑bucket implementation with code examples.

BackendToken Bucketalgorithm
0 likes · 14 min read
Understanding Rate Limiting: Concepts, Architectures, Algorithms, and a Redis‑Lua Token Bucket Implementation
Top Architect
Top Architect
Apr 26, 2021 · Backend Development

Comprehensive Guide to Spring Cloud Zuul Gateway: Functions, Configuration, Filters, Fault Tolerance, Rate Limiting, and Performance Tuning

This article provides an in‑depth tutorial on Spring Cloud Zuul as a microservice gateway, covering its purpose, when to use it, routing configurations, starter dependencies, global variables, filter implementation, Hystrix‑based fault tolerance, rate‑limit protection, and detailed timeout and retry tuning for optimal performance.

MicroservicesSpring CloudZuul
0 likes · 18 min read
Comprehensive Guide to Spring Cloud Zuul Gateway: Functions, Configuration, Filters, Fault Tolerance, Rate Limiting, and Performance Tuning
Wukong Talks Architecture
Wukong Talks Architecture
Apr 15, 2021 · Backend Development

Flash Sale System Design and Optimization

This article outlines common flash‑sale scenarios, identifies key concerns such as overselling, anti‑fraud, and user experience, and progressively presents system designs from a basic SpringBoot‑MyBatis implementation to pessimistic and optimistic locking, rate‑limiting, token‑bucket algorithms, and various performance and security optimizations.

flash salerate limiting
0 likes · 15 min read
Flash Sale System Design and Optimization
Tencent Cloud Developer
Tencent Cloud Developer
Mar 31, 2021 · Backend Development

Design and Implementation of a Distributed Timer Service at Tencent

The article details Tencent’s design and implementation of a distributed timer service—using a multi‑level time‑wheel stored in a KV system, a scheduler daemon, broker, and notifier—to support reliable, low‑latency delayed tasks such as order closure and SMS activation, while addressing isolation, rate limiting, disaster recovery, and delivery guarantees.

KV storageTime Wheeldistributed timer
0 likes · 15 min read
Design and Implementation of a Distributed Timer Service at Tencent
New Oriental Technology
New Oriental Technology
Mar 29, 2021 · Backend Development

Sentinel Flow Control Component: Quick Start, Rules, Annotations, and Internal Mechanisms

This article introduces Alibaba Sentinel, an open‑source flow‑control framework for distributed services, covering Maven integration, dashboard setup, configuration of flow, degrade and hotspot rules, the @SentinelResource annotation, XCloud Sentinel starter usage, and a deep dive into its slot‑chain architecture and sliding‑window algorithm.

Flow ControlHotSpotMicroservices
0 likes · 12 min read
Sentinel Flow Control Component: Quick Start, Rules, Annotations, and Internal Mechanisms
Efficient Ops
Efficient Ops
Mar 25, 2021 · Backend Development

How to Build a Robust Flash‑Sale System that Handles Millions of Requests

This article explores the challenges of designing a flash‑sale (秒杀) system—such as overselling, high concurrency, request flooding, URL protection, and database bottlenecks—and presents a complete backend architecture using Redis, Nginx, rate‑limiting, asynchronous order processing, and service degradation to achieve a stable, high‑throughput solution.

Backend Architectureflash salehigh concurrency
0 likes · 14 min read
How to Build a Robust Flash‑Sale System that Handles Millions of Requests
Selected Java Interview Questions
Selected Java Interview Questions
Mar 20, 2021 · Backend Development

Interview Reflections: HTTP GET Issue, Rate‑Limiting, and ThreadPool Mechanics

The article shares three interview scenarios—a puzzling HTTP GET failure, a rate‑limiting challenge solved with token‑bucket logic, and a deep dive into Java ThreadPoolExecutor behavior—each followed by personal insights on problem‑solving, algorithm application, and understanding underlying principles.

HTTPrate limitingthread pool
0 likes · 10 min read
Interview Reflections: HTTP GET Issue, Rate‑Limiting, and ThreadPool Mechanics
Senior Brother's Insights
Senior Brother's Insights
Mar 14, 2021 · Backend Development

Inside Zhaozhuan’s Service Governance: Architecture, Registration, and Monitoring

Facing the complexities of microservice adoption, Zhaozhuan’s service governance platform integrates service registration, discovery, configuration, monitoring, authentication, and rate limiting via an SDK‑driven architecture, illustrating AP‑style registration, node grouping, gray‑release discovery, real‑time metrics aggregation, and method‑level access control.

Authenticationrate limitingservice governance
0 likes · 14 min read
Inside Zhaozhuan’s Service Governance: Architecture, Registration, and Monitoring
Zhuanzhuan Tech
Zhuanzhuan Tech
Mar 10, 2021 · Backend Development

Service Governance Architecture and Practices at Zhuanzhuan

This article explains how Zhuanzhuan’s service management platform implements comprehensive service governance—including registration, discovery, configuration, monitoring, authentication, rate limiting, and alerting—to support micro‑service architectures and improve reliability, scalability, and operational efficiency.

Configuration ManagementMicroservicesmonitoring
0 likes · 10 min read
Service Governance Architecture and Practices at Zhuanzhuan
php Courses
php Courses
Mar 1, 2021 · Backend Development

Implementing API Rate Limiting with Redis in PHP

This article explains how to implement API request frequency control in PHP using Redis, detailing a function that tracks per‑user request counts within a configurable time window, removes outdated entries, and returns appropriate responses when the limit is exceeded.

APIBackendPHP
0 likes · 3 min read
Implementing API Rate Limiting with Redis in PHP
Top Architect
Top Architect
Feb 14, 2021 · Backend Development

An Introduction to Rate Limiting: Concepts, Classifications, and Go Implementation

This article explains the fundamentals of rate limiting, its importance for high‑availability services, various classification dimensions, common algorithms such as fixed‑window, sliding‑window, leaky‑bucket and token‑bucket, and demonstrates practical usage with Go's golang.org/x/time/rate library including code examples and configuration tips.

Distributed SystemsGolangToken Bucket
0 likes · 26 min read
An Introduction to Rate Limiting: Concepts, Classifications, and Go Implementation
Alibaba Terminal Technology
Alibaba Terminal Technology
Feb 8, 2021 · Cloud Computing

How Alibaba’s Serverless FC Powers Double‑12 Traffic Peaks Without Ops

This article explains how Alibaba Cloud Function Compute (FC) was integrated into internal services to support the Double‑12 promotion, detailing the business requirements, network challenges, hybrid‑cloud solutions, container types, auto‑scaling, rate‑limiting, and the serverless platform’s deployment and gray‑release mechanisms.

Function ComputeServerlesshybrid cloud
0 likes · 15 min read
How Alibaba’s Serverless FC Powers Double‑12 Traffic Peaks Without Ops
Code Ape Tech Column
Code Ape Tech Column
Jan 27, 2021 · Backend Development

An Introduction to Rate Limiting: Concepts, Classifications, Algorithms, and Go Implementation

This article introduces rate limiting, explains its purpose and classifications, compares fixed and sliding windows, describes common algorithms such as token bucket, leaky bucket, and counter, and provides detailed Go code examples using the golang.org/x/time/rate library for practical implementation.

GolangToken Bucketleaky bucket
0 likes · 25 min read
An Introduction to Rate Limiting: Concepts, Classifications, Algorithms, and Go Implementation
21CTO
21CTO
Jan 16, 2021 · Backend Development

How to Build a Go‑Based Log Collection System with etcd, Context, and Kafka

This article walks through designing and implementing a Go log‑collection agent that uses etcd for configuration storage, context for timeout and metadata handling, and Kafka for message consumption, complete with code examples, setup instructions, and a rate‑limiting utility.

GoKafkacontext
0 likes · 16 min read
How to Build a Go‑Based Log Collection System with etcd, Context, and Kafka
Top Architect
Top Architect
Jan 15, 2021 · Backend Development

Design and Technical Solutions for a High‑Concurrency Flash Sale System

This article examines the challenges of building a flash‑sale (秒杀) system—such as overselling, massive concurrent requests, URL exposure, and database bottlenecks—and presents a comprehensive backend architecture that combines separate databases, dynamic URLs, static pages, Redis clustering, Nginx load balancing, SQL optimization, rate‑limiting, asynchronous order processing, and service degradation techniques.

Nginxbackend designflash sale
0 likes · 13 min read
Design and Technical Solutions for a High‑Concurrency Flash Sale System
21CTO
21CTO
Jan 9, 2021 · Backend Development

How to Build a Robust Flash‑Sale System that Handles Millions of Requests

This article explores the key challenges of designing a flash‑sale (秒杀) system—such as overselling, high concurrency, request flooding, and database strain—and presents a comprehensive backend architecture with database design, dynamic URLs, caching, rate limiting, async ordering, and service degradation techniques.

Backend ArchitectureDatabase designasynchronous processing
0 likes · 13 min read
How to Build a Robust Flash‑Sale System that Handles Millions of Requests
dbaplus Community
dbaplus Community
Jan 7, 2021 · Information Security

Understanding CC Attacks and Slow DDoS: Mechanisms, Tools, and Defenses

This article explains how CC (Challenge Collapsar) attacks and their slow‑request variants overwhelm web services, describes the underlying botnet concepts, shows practical attack commands with tools like slowhttptest, and outlines multiple mitigation strategies such as rate limiting, IP hiding, high‑protection IP services, and static page optimization.

BotnetCC AttackDDoS
0 likes · 18 min read
Understanding CC Attacks and Slow DDoS: Mechanisms, Tools, and Defenses
Xueersi Online School Tech Team
Xueersi Online School Tech Team
Dec 25, 2020 · Backend Development

Implementing Message Queues with Redis: Lists, Zsets, Pub/Sub, and Streams

This article explains how Redis can be used to build lightweight, high‑performance message queues by leveraging lists for simple queues, sorted sets for delayed delivery, Pub/Sub for multicast, and the Stream data structure for durable, scalable messaging, while also covering practical PHP implementations, acknowledgment, retry, graceful restart, and rate‑limiting techniques.

Message QueuePHPPubSub
0 likes · 19 min read
Implementing Message Queues with Redis: Lists, Zsets, Pub/Sub, and Streams
Python Crawling & Data Mining
Python Crawling & Data Mining
Dec 25, 2020 · Backend Development

Mastering Python Rate Limiting: From ratelimiter to SlowAPI

This article explains how to control request frequency in Python using the ratelimiter library for synchronous and asynchronous code, and introduces SlowAPI as a flexible solution for FastAPI and Flask, helping backend developers reduce server load and protect APIs from abuse.

FastAPIPythonasyncio
0 likes · 6 min read
Mastering Python Rate Limiting: From ratelimiter to SlowAPI
Java Backend Technology
Java Backend Technology
Dec 19, 2020 · Databases

Deep Dive into Redis: Data Structures, Persistence, and High Availability

This comprehensive guide explores Redis internals, covering its core data types and their low‑level implementations, persistence mechanisms like RDB and AOF, performance tricks, common pitfalls such as cache avalanche and split‑brain, distributed locking strategies, expiration and eviction policies, high‑availability architectures, and rate‑limiting techniques.

Persistencehigh availabilityrate limiting
0 likes · 35 min read
Deep Dive into Redis: Data Structures, Persistence, and High Availability
Java Architect Essentials
Java Architect Essentials
Dec 14, 2020 · Backend Development

How to Set Up Alibaba Sentinel for Rate Limiting in a Spring Boot Microservice

This guide walks you through installing Alibaba Sentinel’s dashboard, configuring a Spring Boot client, defining flow rules, and verifying that request throttling works, providing all necessary commands, Maven snippets, YAML settings, and UI screenshots for a complete end‑to‑end rate‑limiting solution.

MicroservicesSpring Bootcircuit breaker
0 likes · 10 min read
How to Set Up Alibaba Sentinel for Rate Limiting in a Spring Boot Microservice
Programmer DD
Programmer DD
Dec 13, 2020 · Backend Development

Master Sliding Window Rate Limiting in Java with Simple Code

This article introduces a straightforward Java implementation of a sliding‑window rate‑limiting algorithm for single‑machine use, explains its core logic, demonstrates its behavior with sample output, and visualizes the step‑by‑step process of how timestamps are managed within the window.

Sliding Windowalgorithmjava
0 likes · 8 min read
Master Sliding Window Rate Limiting in Java with Simple Code
vivo Internet Technology
vivo Internet Technology
Dec 2, 2020 · Cloud Native

In‑Depth Analysis of Sentinel's Rate‑Limiting Mechanism

Sentinel implements rate‑limiting through a chain‑of‑responsibility where annotated methods trigger SphU.entry, creating a Context, Node, and Entry; slots such as NodeSelectorSlot, ClusterBuilderSlot, StatisticSlot, and FlowSlot update sliding‑window metrics via LeapArray and enforce QPS thresholds, throwing BlockException on violations.

Circuit BreakingSliding Windowjava
0 likes · 18 min read
In‑Depth Analysis of Sentinel's Rate‑Limiting Mechanism
Laravel Tech Community
Laravel Tech Community
Nov 26, 2020 · Backend Development

Design and Technical Solutions for a High-Concurrency Flash Sale System

This article examines the challenges of building a flash‑sale (秒杀) system—such as overselling, high concurrency, request flooding, URL security, and database strain—and presents a comprehensive backend design using separate databases, Redis clustering, dynamic URLs, static pages, Nginx, rate‑limiting, asynchronous order processing, and service degradation strategies.

asynchronous processingbackend designflash sale
0 likes · 11 min read
Design and Technical Solutions for a High-Concurrency Flash Sale System
HaoDF Tech Team
HaoDF Tech Team
Nov 17, 2020 · Backend Development

Introduction to API Gateway and Kong Implementation at Haodf

This article introduces the fundamentals of API gateways, explains why Haodf replaced Nginx with Kong, details Kong's architecture, plugins, traffic segmentation, rate‑limiting strategies, monitoring, and operational considerations for deploying Kong in a micro‑service environment.

Kongapi-gatewaybackend-development
0 likes · 16 min read
Introduction to API Gateway and Kong Implementation at Haodf
Wukong Talks Architecture
Wukong Talks Architecture
Oct 21, 2020 · Backend Development

Flash Sale (Seckill) System Architecture Explained Through a Sci‑Fi Narrative

This article uses a sci‑fi story set on the A‑731 e‑commerce planet to illustrate the core principles of flash‑sale systems, including single‑responsibility services, independent deployment, stock pre‑heating, request encryption, static‑dynamic separation, traffic shaping, rate limiting, queue‑based load smoothing, and the role of Redis, Nginx, CDN and Redisson in handling massive order spikes.

Seckillflash salerate limiting
0 likes · 10 min read
Flash Sale (Seckill) System Architecture Explained Through a Sci‑Fi Narrative
Top Architect
Top Architect
Oct 21, 2020 · Backend Development

Design and Technical Solutions for a High‑Concurrency Flash Sale System

This article examines the challenges of building a flash‑sale (秒杀) system—such as overselling, high concurrency, request throttling, and database strain—and presents a comprehensive backend design using separate databases, dynamic URLs, static pages, Redis clustering, Nginx, token‑bucket rate limiting, asynchronous order processing, and service degradation strategies.

asynchronous processingbackend designflash sale
0 likes · 15 min read
Design and Technical Solutions for a High‑Concurrency Flash Sale System
Architects' Tech Alliance
Architects' Tech Alliance
Oct 12, 2020 · Operations

Designing Resilient Microservices: Patterns for Fault Tolerance and Failure Management

This article examines the inherent risks of microservice architectures and presents practical patterns—such as graceful degradation, change management, health checks, self‑healing, fallback caching, retries, rate limiting, bulkheads, and circuit breakers—to build highly available, fault‑tolerant services.

MicroservicesResiliencebulkhead
0 likes · 15 min read
Designing Resilient Microservices: Patterns for Fault Tolerance and Failure Management
Java Architect Essentials
Java Architect Essentials
Oct 5, 2020 · Backend Development

Implementing Distributed Rate Limiting in Spring Cloud Gateway with Token Bucket and Lua Script

This article explains how Spring Cloud Gateway uses a token‑bucket algorithm backed by Redis and a Lua script to perform distributed rate limiting, reviews common limiting algorithms, provides detailed Java and Lua code examples, and analyzes each step of the implementation for high‑concurrency systems.

Distributed SystemsLuaSpring Cloud Gateway
0 likes · 7 min read
Implementing Distributed Rate Limiting in Spring Cloud Gateway with Token Bucket and Lua Script
ITFLY8 Architecture Home
ITFLY8 Architecture Home
Sep 22, 2020 · Operations

How to Build Highly Available, Scalable, and Resilient Systems

This article explains the principles and practical techniques for achieving high availability, scalability, isolation, decoupling, rate limiting, degradation, and circuit breaking in modern software systems, providing concrete examples, algorithms, and deployment patterns to improve reliability and performance.

ScalabilitySystem Designcircuit breaker
0 likes · 18 min read
How to Build Highly Available, Scalable, and Resilient Systems
ITFLY8 Architecture Home
ITFLY8 Architecture Home
Sep 20, 2020 · Backend Development

How to Build a Robust Flash Sale System: Architecture, Challenges, and Code Solutions

This article examines the critical issues of overselling, high concurrency, request throttling, and database design in flash‑sale systems, then outlines a comprehensive backend architecture with Redis clustering, Nginx load balancing, dynamic URLs, rate‑limiting, asynchronous order processing, and Java code examples to achieve a resilient high‑throughput solution.

Backend Architectureflash salehigh concurrency
0 likes · 13 min read
How to Build a Robust Flash Sale System: Architecture, Challenges, and Code Solutions
Aikesheng Open Source Community
Aikesheng Open Source Community
Sep 17, 2020 · Backend Development

Understanding Rate Limiting: Leaky Bucket and Token Bucket Algorithms with a Python Example

This article explains the principles of leaky‑bucket and token‑bucket rate‑limiting algorithms, compares their behavior in high‑concurrency e‑commerce scenarios, and provides a complete Python implementation to illustrate how token‑bucket can handle burst traffic while maintaining system stability.

PythonToken Buckethigh concurrency
0 likes · 7 min read
Understanding Rate Limiting: Leaky Bucket and Token Bucket Algorithms with a Python Example
Liangxu Linux
Liangxu Linux
Aug 6, 2020 · Backend Development

Mastering Nginx Rate Limiting: From Basics to Advanced Configurations

This guide explains how Nginx implements rate limiting using the leaky‑bucket algorithm, walks through basic and advanced configurations—including limit_req_zone, limit_req, burst, nodelay, whitelisting, multiple limits, logging, and custom status codes—while providing concrete code examples and practical tips.

Configurationleaky bucketlimit_req
0 likes · 14 min read
Mastering Nginx Rate Limiting: From Basics to Advanced Configurations
IT Architects Alliance
IT Architects Alliance
Aug 4, 2020 · Backend Development

Designing Effective Rate Limiting and Circuit Breaking for Microservice APIs

This article examines the motivations, resource granularity, rule definition, and calculation logic behind implementing rate limiting and circuit breaking in microservice architectures, using examples like Sentinel and Hystrix, and outlines a step-by-step design for integrating these controls with API gateways.

Backend ArchitectureCircuit BreakingHystrix
0 likes · 14 min read
Designing Effective Rate Limiting and Circuit Breaking for Microservice APIs
21CTO
21CTO
Jul 22, 2020 · Information Security

Why RESTful API Security Matters and How to Protect Your APIs

This article explains the critical importance of securing RESTful APIs—covering data protection, DoS risks, and business impact—and outlines practical measures such as authentication, API keys, access control, rate limiting, and input validation with code examples.

API SecurityAuthenticationRESTful API
0 likes · 8 min read
Why RESTful API Security Matters and How to Protect Your APIs
MaGe Linux Operations
MaGe Linux Operations
Jul 18, 2020 · Backend Development

Master Nginx Rate Limiting: From Basics to Advanced Configurations

This article explains Nginx rate‑limiting fundamentals and advanced configurations, covering the leaky‑bucket algorithm, basic directives, burst and nodelay handling, whitelisting with geo/map, multiple limit rules, logging details, and custom error responses to protect servers and mitigate attacks.

ConfigurationNginxWeb server
0 likes · 11 min read
Master Nginx Rate Limiting: From Basics to Advanced Configurations
Selected Java Interview Questions
Selected Java Interview Questions
Jun 28, 2020 · Backend Development

Rate Limiting Strategies and Guava RateLimiter for High Concurrency Traffic

This article explains the concept of high traffic, compares common mitigation techniques such as caching, degradation and rate limiting, and then details four classic rate‑limiting algorithms—counter, sliding window, leaky bucket and token bucket—followed by a practical Guava RateLimiter example and a brief note on distributed scenarios.

Distributed SystemsGuavahigh concurrency
0 likes · 7 min read
Rate Limiting Strategies and Guava RateLimiter for High Concurrency Traffic
Alibaba Cloud Developer
Alibaba Cloud Developer
Jun 24, 2020 · Backend Development

Choosing the Right Rate‑Limiting Algorithm: Simple Window, Sliding Window, Leaky Bucket, Token Bucket & Sliding Log

This article explains the purpose of flow control, compares various rate‑limiting algorithms—including simple window, sliding window, leaky bucket, token bucket, and sliding log—provides Java interface definitions and code examples, discusses their complexity, precision, smoothness, and suitability for single‑machine and distributed scenarios, and offers practical deployment tips using Sentinel, Nginx, Guava, Tair, and Redis.

Distributed Systemsalgorithmjava
0 likes · 31 min read
Choosing the Right Rate‑Limiting Algorithm: Simple Window, Sliding Window, Leaky Bucket, Token Bucket & Sliding Log
37 Interactive Technology Team
37 Interactive Technology Team
Jun 12, 2020 · Cloud Native

Implementing Dynamic Rate Limiting with the APISIX API Gateway

This tutorial shows how to use the open‑source APISIX API gateway—built on OpenResty and etcd—to create a dynamic rate‑limiting plugin in Lua, configure route matching with a radix tree, and demonstrate the feature with a test endpoint that enforces one request per second and returns HTTP 503 when exceeded.

APISIXDynamic Rate LimitingLua
0 likes · 14 min read
Implementing Dynamic Rate Limiting with the APISIX API Gateway
Beike Product & Technology
Beike Product & Technology
Jun 5, 2020 · Cloud Native

Fundamentals of Microservice Architecture: Service Splitting, Registration, Load Balancing, Rate Limiting, and Circuit Breaking

This article provides a comprehensive introduction to microservice architecture, covering service decomposition, registration and discovery methods, client‑driven load balancing, rate‑limiting and circuit‑breaking strategies, and the design of a self‑built application delivery platform for cloud‑native environments.

Circuit BreakingCloud NativeOperations
0 likes · 23 min read
Fundamentals of Microservice Architecture: Service Splitting, Registration, Load Balancing, Rate Limiting, and Circuit Breaking
FunTester
FunTester
May 27, 2020 · Backend Development

How to Simulate Fixed QPS Mock APIs with Java Semaphore and Moco

This article explains how to overcome the difficulty of isolating external service performance during load testing by creating a fixed‑QPS mock endpoint using Java's Semaphore and a custom Moco ResponseHandler, includes code samples, accuracy observations, and practical guidelines.

MoCoMock APIPerformance Testing
0 likes · 5 min read
How to Simulate Fixed QPS Mock APIs with Java Semaphore and Moco
JD Retail Technology
JD Retail Technology
May 25, 2020 · Backend Development

Understanding Rate Limiting: Counter, Leaky Bucket, and Token Bucket Algorithms

This article explains the fundamentals of rate limiting for high‑concurrency systems, covering why it is needed, the conditions that trigger it, and detailed introductions to the three main algorithms—counter (fixed and sliding windows), leaky bucket, and token bucket—along with their advantages, drawbacks, and sample pseudo‑code implementations.

BackendToken Bucketcounter algorithm
0 likes · 13 min read
Understanding Rate Limiting: Counter, Leaky Bucket, and Token Bucket Algorithms
58 Tech
58 Tech
May 22, 2020 · Backend Development

Design and Implementation of a Distributed Retry System Based on Distributed Scheduling

This article presents a comprehensive distributed retry system that leverages a distributed scheduling mechanism to ensure eventual consistency, reduce manual recovery costs, and provide flexible retry strategies, automatic recovery detection, visual management, rate limiting, and intelligent retry for backend services.

backend-developmentfault toleranceintelligent retry
0 likes · 13 min read
Design and Implementation of a Distributed Retry System Based on Distributed Scheduling
Java Captain
Java Captain
May 17, 2020 · Information Security

Common API Security Measures and Their Implementation

This article outlines essential API security mechanisms—including encryption, signing, timestamps, AppId authentication, rate limiting, blacklisting, and data validation—and provides practical Java implementation examples and code snippets.

AppIdBlacklistencryption
0 likes · 10 min read
Common API Security Measures and Their Implementation
Java Backend Technology
Java Backend Technology
May 14, 2020 · Backend Development

How to Build a High‑Performance Flash Sale System: Architecture & Code

This article explores the key challenges of designing a flash‑sale (秒杀) backend—such as overselling, high concurrency, request throttling, and database bottlenecks—and presents a complete solution that includes database schema, dynamic URLs, static page rendering, Redis clustering, Nginx load balancing, SQL optimization, token‑bucket rate limiting, asynchronous order processing, and service degradation strategies.

Backend Architectureflash salehigh concurrency
0 likes · 14 min read
How to Build a High‑Performance Flash Sale System: Architecture & Code
58 Tech
58 Tech
May 13, 2020 · Information Security

Dynamic Signature Strategies for API Security: Attack and Defense Techniques

This article explores the cat‑and‑mouse battle between crawlers and API endpoints, detailing how dynamic signatures, token‑based authentication, time‑bound hashes, rate‑limiting, and code obfuscation can be used to defend against scraping while also showing how attackers can reverse‑engineer and bypass these defenses.

API Securityanti‑crawlingcode obfuscation
0 likes · 12 min read
Dynamic Signature Strategies for API Security: Attack and Defense Techniques
Top Architect
Top Architect
May 12, 2020 · Backend Development

Design and Technical Solutions for a High‑Concurrency Flash Sale System

This article explores the challenges of building a flash‑sale (秒杀) backend—such as overselling, massive concurrent requests, URL protection, and database bottlenecks—and presents a comprehensive architecture that leverages Redis clustering, token‑bucket rate limiting, static page rendering, asynchronous order processing, and service degradation techniques.

flash salehigh concurrencyrate limiting
0 likes · 12 min read
Design and Technical Solutions for a High‑Concurrency Flash Sale System
21CTO
21CTO
May 2, 2020 · Backend Development

Master Distributed Caching, Rate Limiting, Locks & Idempotency with Alibaba Tools

This article introduces Alibaba's distributed‑tools component, explaining how to configure Redis/Tair cache, implement fixed‑window rate limiting, use a high‑performance distributed lock template, and apply idempotency mechanisms with annotations and templates to ensure reliable microservice operations.

IdempotencySpringBootcaching
0 likes · 15 min read
Master Distributed Caching, Rate Limiting, Locks & Idempotency with Alibaba Tools
Programmer DD
Programmer DD
Apr 29, 2020 · Operations

How to Keep Your Distributed System Running Even When Upstream Services Fail

The article explains why distributed systems must stay alive despite upstream or downstream failures, emphasizing rate limiting and circuit breaking as essential practices to prevent fault propagation and ensure service reliability, and it invites developers to assess their own safeguards.

Circuit BreakingDistributed Systemsrate limiting
0 likes · 3 min read
How to Keep Your Distributed System Running Even When Upstream Services Fail
Tencent Cloud Developer
Tencent Cloud Developer
Apr 22, 2020 · Cloud Native

Designing High‑Quality Service Architecture Under Traffic Peaks: Load Balancing, Rate Limiting, Retries, Timeouts, and Failure Mitigation

Drawing on Google SRE principles, Bilibili’s technical director outlines a systematic, cloud‑native framework for high‑quality service architecture during traffic peaks, covering frontend and internal load balancing, distributed rate limiting, controlled retries, fail‑fast timeouts, and comprehensive failure‑mitigation strategies.

SREcloud-nativeload balancing
0 likes · 13 min read
Designing High‑Quality Service Architecture Under Traffic Peaks: Load Balancing, Rate Limiting, Retries, Timeouts, and Failure Mitigation
Programmer DD
Programmer DD
Apr 20, 2020 · Information Security

Essential API Security Measures and How to Implement Them

This article outlines key security mechanisms for public APIs—including data encryption, signing, timestamp validation, AppId authentication, rate limiting, blacklist handling, and data validation—and provides practical Java code examples for each technique.

API SecurityAuthenticationdata encryption
0 likes · 11 min read
Essential API Security Measures and How to Implement Them
Architecture Digest
Architecture Digest
Apr 14, 2020 · Operations

Nginx Rate Limiting: Token‑Bucket, Leaky‑Bucket Algorithms and Configuration Examples

This article explains the principles of token‑bucket and leaky‑bucket rate‑limiting algorithms, shows how Nginx implements them with the limit_req and limit_conn modules, and provides detailed configuration examples—including burst, nodelay, and custom status codes—to control request rates and concurrent connections.

Token Bucketleaky bucketlimit_conn
0 likes · 12 min read
Nginx Rate Limiting: Token‑Bucket, Leaky‑Bucket Algorithms and Configuration Examples
Xiao Lou's Tech Notes
Xiao Lou's Tech Notes
Apr 11, 2020 · Backend Development

Why Sentinel Misses Docker CPU Usage and How to Fix It

This article explains Sentinel's role in microservice rate limiting, details a Docker-specific bug where CPU utilization is incorrectly reported, clarifies the difference between CPU load and utilization, and outlines the code fix and its remaining limitations.

Dockercpu-utilizationjava
0 likes · 6 min read
Why Sentinel Misses Docker CPU Usage and How to Fix It
Architecture Digest
Architecture Digest
Mar 30, 2020 · Backend Development

Design and Technical Solutions for a High‑Concurrency Flash Sale System

This article examines the challenges of building a flash‑sale (秒杀) system—such as overselling, massive concurrent requests, URL exposure, and database overload—and presents a comprehensive backend architecture that leverages Redis clustering, dynamic URLs, Nginx load balancing, rate‑limiting, asynchronous order processing, and service degradation techniques to achieve robust, scalable performance.

Backend Architectureasynchronous processingflash sale
0 likes · 12 min read
Design and Technical Solutions for a High‑Concurrency Flash Sale System
ITFLY8 Architecture Home
ITFLY8 Architecture Home
Mar 28, 2020 · Backend Development

Master Rate Limiting: Algorithms, Guava RateLimiter, and Java Implementation

This article introduces the background and necessity of rate limiting, explains the leaky bucket and token bucket algorithms with visual diagrams, and provides a comprehensive Java implementation using Guava's RateLimiter, custom annotations, AOP interception, and controller integration to protect high‑traffic applications.

Guavaaoprate limiting
0 likes · 10 min read
Master Rate Limiting: Algorithms, Guava RateLimiter, and Java Implementation
macrozheng
macrozheng
Mar 25, 2020 · Backend Development

Mastering Token Bucket Rate Limiting and Lock Strategies in Flash Sale Systems

This article explains how to implement token‑bucket rate limiting with Guava's RateLimiter, compare it to leaky‑bucket algorithms, and combine it with optimistic and pessimistic locking techniques to prevent overselling in high‑concurrency flash‑sale applications.

Token Bucketjavaoptimistic lock
0 likes · 15 min read
Mastering Token Bucket Rate Limiting and Lock Strategies in Flash Sale Systems
21CTO
21CTO
Mar 24, 2020 · Operations

Mastering System Resilience: Rate Limiting, Circuit Breaking, and Degradation

To keep systems highly available under sudden traffic spikes, developers employ three core strategies—rate limiting, circuit breaking, and service degradation—each controlling request flow, isolating failures, and gracefully reducing functionality to maintain stability, with practical examples and algorithmic approaches explained.

Circuit BreakingOperationsrate limiting
0 likes · 5 min read
Mastering System Resilience: Rate Limiting, Circuit Breaking, and Degradation
Youzan Coder
Youzan Coder
Mar 11, 2020 · Backend Development

Youzan Task Scheduling Platform (TSP): Design, Implementation, and Future Roadmap

Youzan’s Task Scheduling Platform (TSP) unifies its legacy cron and timeout systems into a modular, extensible framework that supports both timed and delayed tasks, offering per‑task rate limiting, sharding, isolation, retry policies, and a rich SDK, while its roadmap adds end‑to‑end monitoring, workflow orchestration, domain‑level clustering, transactional messaging, and dynamic task registration.

BackendTSParchitecture
0 likes · 14 min read
Youzan Task Scheduling Platform (TSP): Design, Implementation, and Future Roadmap
21CTO
21CTO
Feb 26, 2020 · Backend Development

Mastering Distributed Rate Limiting: Caching, Degradation, and Flow Control Techniques

This article explains how caching, degradation, and various rate‑limiting strategies—including semaphore‑based concurrency control, token‑bucket algorithms, Guava RateLimiter, custom annotations, Redis interceptors, and Nginx modules—protect high‑concurrency distributed systems, with practical Java code samples and configuration snippets.

Distributed Systemscachingdegradation
0 likes · 19 min read
Mastering Distributed Rate Limiting: Caching, Degradation, and Flow Control Techniques
Big Data Technology & Architecture
Big Data Technology & Architecture
Feb 22, 2020 · Backend Development

Understanding Rate Limiting: Leaky Bucket, Token Bucket, and Guava RateLimiter

The article explains the principles of traffic shaping through leaky‑bucket and token‑bucket algorithms, details how Google Guava's RateLimiter implements token‑bucket rate limiting, and provides Java code examples illustrating token generation, acquisition, and practical usage in high‑concurrency backend systems.

BackendGuavaToken Bucket
0 likes · 10 min read
Understanding Rate Limiting: Leaky Bucket, Token Bucket, and Guava RateLimiter
Qunar Tech Salon
Qunar Tech Salon
Feb 4, 2020 · Backend Development

Bilibili's Exploration and Practice of Microservice Governance

This article presents Bilibili's exploration of microservice governance, detailing the challenges of service splitting and large‑scale management, the design and evolution of its Go‑based Discovery service discovery framework, advanced load‑balancing algorithms, adaptive rate‑limiting, circuit‑breaking strategies, and future directions for resilient backend systems.

Circuit BreakingGoload balancing
0 likes · 13 min read
Bilibili's Exploration and Practice of Microservice Governance
Programmer DD
Programmer DD
Jan 7, 2020 · Backend Development

Designing Secure and User‑Friendly SMS Verification Systems

This article explores common pitfalls and best‑practice design patterns for SMS verification, covering cross‑origin issues, rate‑limiting, captcha integration, IP/Cookie restrictions, and alert mechanisms to balance security and user experience across web and mobile platforms.

MobileSMS Verificationrate limiting
0 likes · 9 min read
Designing Secure and User‑Friendly SMS Verification Systems
Qunar Tech Salon
Qunar Tech Salon
Jan 7, 2020 · Operations

Comprehensive Dependency Governance for High‑Availability Backend Systems

This article outlines a systematic approach to dependency governance in high‑traffic backend services, covering service classification, rate limiting, Dubbo, HTTP, database, and message‑queue management to enhance availability, reduce failure impact, and improve overall system stability.

DubboOperationsdependency management
0 likes · 10 min read
Comprehensive Dependency Governance for High‑Availability Backend Systems
Programmer DD
Programmer DD
Jan 1, 2020 · Backend Development

How to Build a High‑Performance Flash Sale System: Architecture & Code

This article examines the key challenges of flash‑sale (秒杀) systems—overselling, massive concurrency, URL exposure, and database coupling—and presents a complete backend design featuring dedicated databases, dynamic URLs, static pages, Redis clustering, Nginx proxy, rate‑limiting, token‑bucket control, asynchronous order queues, and service degradation strategies.

Backend Architectureflash salehigh concurrency
0 likes · 14 min read
How to Build a High‑Performance Flash Sale System: Architecture & Code
Senior Brother's Insights
Senior Brother's Insights
Dec 27, 2019 · Backend Development

How to Build a High‑Performance Flash Sale System: Architecture, Strategies & Code

This article examines the challenges of designing a robust flash‑sale backend—preventing oversell, handling massive concurrent requests, securing URLs, isolating databases, and applying techniques such as Redis clustering, Nginx load balancing, rate limiting, asynchronous processing, and service degradation—to enable stable, low‑latency sales spikes.

Backend ArchitectureNginxflash sale
0 likes · 15 min read
How to Build a High‑Performance Flash Sale System: Architecture, Strategies & Code
Java Captain
Java Captain
Dec 2, 2019 · Backend Development

Implementing Interface Rate Limiting in Spring Boot with Annotations and Redis

This article demonstrates how to create a custom @AccessLimit annotation, implement a Spring MVC interceptor that uses Redis to count requests, register the interceptor in a Spring Boot application, and apply the annotation to controller methods to achieve rate‑limiting functionality.

InterceptorSpring Bootannotations
0 likes · 6 min read
Implementing Interface Rate Limiting in Spring Boot with Annotations and Redis
Youku Technology
Youku Technology
Nov 5, 2019 · Backend Development

Traffic Shaping Strategies for High‑Concurrency Events: Staggering, Rate Limiting, and Peak Cutting

The article explains how Youku’s engineers mitigate extreme traffic spikes during large‑scale events by applying three core techniques—staggering requests across time, enforcing client‑side rate limits, and cutting peaks through minimum intervals, probabilistic sending and fairness algorithms—to lower maximum QPS, improve stability, and preserve user experience.

QPSScalabilityTraffic Shaping
0 likes · 8 min read
Traffic Shaping Strategies for High‑Concurrency Events: Staggering, Rate Limiting, and Peak Cutting