Analyzing the Feasibility of Supporting One Million Concurrent Requests in a Typical System Architecture

The article introduces a simplified, typical system architecture and investigates whether it can theoretically support one million concurrent requests.

To reduce complexity, the system is illustrated as shown below:

The architecture consists of the following components:

Gateway layer: Load Balancer / API Gateway

Service layer: HTTP Server

Middleware: Redis, MQ

Storage layer: MySQL / PostgreSQL

Each component is analyzed in turn.

Load Balancer

The load balancer’s primary role is traffic distribution, while an API gateway adds functions such as API management, security, transformation, and monitoring. Load balancers can be hardware, software, or cloud‑based; common open‑source options include Nginx, HAProxy, Kong, Traefik, and Envoy. Reported RPS ranges from tens of thousands to several hundred thousand, with high‑end hardware or cloud services claiming support for millions of requests per second.

Reference: HAProxy single instance up to 2 M RPS; AWS NLB up to 1 M RPS.

HTTP Server

Ignoring business logic, HTTP servers built with various frameworks can achieve tens of thousands to several hundred thousand RPS, and some reach the million‑level. Their stateless nature enables easy horizontal scaling, making million‑concurrent handling feasible.

Reference: Web Framework Benchmark.

Redis

A single Redis node can handle about 100 k QPS; with Redis Cluster, total QPS scales linearly (m × n). Official limits allow up to 1 000 nodes, enabling million‑to‑tens‑of‑million QPS, and AWS reports 500 M QPS for a single cluster.

Reference: Redis Cluster specifications; AWS Redis cluster performance.

Message Queue (MQ)

Message queues convert concurrent request load into per‑second message ingestion. Because MQs typically use append‑only writes and support clustering, handling a million messages per second is achievable.

Reference: Kafka achieving 2 M writes per second on three inexpensive machines.

MySQL / PostgreSQL

Performance tests from a cloud provider show that a MySQL 5.7 instance with 16 CPU / 64 GB RAM and concurrency 128 reaches less than 140 k QPS and about 7 k TPS. Connection‑per‑thread architecture makes it impossible for a single relational database to sustain a million QPS without sharding, caching, or throttling.

Reference: MySQL 5.7 performance test.

Network

Network bandwidth is a critical factor. Typical data‑center links range from 10 Gbps to 400 Gbps. At 10 Gbps (1.25 GB/s), serving one‑million 1 KB requests per second would require roughly 1 GB/s, approaching the limit of a 10 Gbps link.

Conclusion

By theoretically evaluating each layer’s performance ceiling, the article shows that most components—load balancers, HTTP servers, Redis, and MQ—can individually handle million‑level concurrency, while relational databases and network bandwidth become bottlenecks that require scaling strategies such as sharding, caching, or higher‑capacity links. Real‑world maximum concurrency must ultimately be verified through load testing.