Server Capacity Calculator

Calculate server resource requirements based on expected traffic, workload type, and performance goals. Get recommendations for CPU, RAM, storage, and bandwidth.

Try a common case
KB
ms

Quick Reference

Typical Web App
2-4 vCPU, 4-8 GB RAM
per 1,000 concurrent users
API Server
4-8 vCPU, 8-16 GB RAM
per 5,000 req/sec
Database Server
8+ vCPU, 32+ GB RAM
SSD storage recommended
N+1 Redundancy
50% extra capacity
Industry standard for HA

Capacity Requirements

Calculated
CPU Cores
0
vCPU recommended
Memory (RAM)
0 GB
Total memory
Bandwidth
0 Mbps
Network throughput
Requests/Sec
0
Peak throughput
Provider Instance Type vCPU Memory Est. Cost/mo

Recommendations

Frequently Asked Questions

What does requests per user per minute mean?
It is how many requests one active user sends to your server each minute, including page loads, API calls and background polling. A relaxed browsing session might be 5 to 10; a chatty single-page app can be much higher.
How do you calculate server capacity for a web application?
Server capacity planning involves estimating peak request load and matching it to available server resources. Step-by-step approach: 1. Estimate peak requests per second (RPS): calculate from traffic data or projections. Peak RPS is typically 2–5× average RPS for consumer apps; up to 10× for event-driven traffic (ticket sales, product launches). 2. Determine resources per request: measure (using load testing, profiling, or benchmarking): CPU time per request (milliseconds). Memory per request (MB). Average response time (milliseconds). 3. Apply Little's Law for concurrency: concurrent requests = RPS × average response time (in seconds). Example: 100 RPS × 0.1 sec/request = 10 concurrent requests. 4. Estimate CPU requirements: CPU threads needed = concurrent requests / CPU_efficiency. For 10 concurrent requests at 50% CPU efficiency: need 20 "thread slots" → ~4–6 CPU cores. 5. Estimate memory requirements: total RAM = (concurrent requests × memory per request) + OS overhead + caching. Example: 100 concurrent requests × 20 MB/request = 2,000 MB + 512 MB OS = ~2.5 GB minimum. 6. Add safety margins: plan for 70% CPU utilization maximum. Add 30% memory headroom. Apply N+1 redundancy (always have 1 spare server). 7. Account for growth: plan for 12–18 months of expected growth. Build in autoscaling for variable load patterns. For precise capacity planning: use load testing tools (Apache JMeter, k6, Locust) to measure actual resource consumption under realistic load before production deployment.
What is the difference between horizontal and vertical server scaling?
Scaling a server infrastructure means increasing its capacity to handle more load. There are two fundamental approaches: vertical scaling (scale up): add more resources (CPU, RAM, disk) to an existing server. Example: upgrade from a 4-core/16 GB server to a 16-core/64 GB server. Pros: simpler — no code changes, no load balancer needed, works for stateful apps. Cons: has a hard ceiling (largest available instance/machine). Costs rise non-linearly at the top end. Creates a single point of failure. Requires downtime on-premises (live resize available in some cloud environments). Horizontal scaling (scale out): add more servers and distribute the load across them. Example: add 4 more servers behind a load balancer. Pros: virtually unlimited — add more servers as needed. Higher availability (failure of one server doesn't stop service). More cost-efficient at scale. Cons: requires stateless design (application can't rely on local session data between requests). Load balancer needed. Session management complexity (sticky sessions, distributed cache). More operational complexity. When to use which: vertical: databases (PostgreSQL, MySQL) — early scaling; simpler; some SQL databases don't easily scale horizontally. Legacy applications designed for a single machine. Small to medium scale where operational simplicity matters. Horizontal: web servers, API servers, stateless microservices. Any system requiring high availability. Large scale where cost efficiency matters. Cloud environments with autoscaling: cloud platforms (AWS, GCP, Azure) make horizontal scaling much easier with managed load balancers and auto-scaling groups. Modern architecture: most large-scale systems use a hybrid — vertically scaled databases + horizontally scaled application servers.
How many requests per second can a server handle?
Server request handling capacity varies enormously depending on the application type, server hardware, and how each request is processed. Representative benchmarks (single server, typical production hardware): nginx serving static files: 10,000–50,000+ RPS — mostly I/O bound, extremely efficient. Node.js REST API: 1,000–10,000 RPS — asynchronous; good performance for I/O-heavy operations. Go REST API: 2,000–15,000 RPS — compiled; highly efficient. Python Flask/Django: 100–1,000 RPS — GIL limits true parallelism; use async frameworks or multiple workers. Java Spring Boot: 500–5,000 RPS — JVM has overhead but scales well with tuning. PHP/WordPress: 100–500 RPS (with caching) — database queries often the bottleneck. Database queries (PostgreSQL): 1,000–10,000 QPS for simple queries; complex queries dramatically reduce this. Factors that determine RPS: CPU count and speed: more cores and faster clock speeds directly increase RPS. Request complexity: a simple health check might handle 50,000 RPS; a request that queries a database and runs business logic might handle 500 RPS. I/O binding: if requests mostly wait for database/API responses, async architectures handle much higher RPS on the same hardware. Memory: insufficient memory causes swapping, which destroys throughput. Network bandwidth: at very high RPS, network becomes the bottleneck before CPU. How to measure your actual capacity: use load testing tools like k6, Apache JMeter, or wrk. Ramp up request rate while monitoring CPU, memory, response times, and error rates. Your real capacity limit is where response time or error rate becomes unacceptable — typically at 60–80% CPU utilization for CPU-bound workloads.
What is server utilization and what percentage should I target?
Server utilization is the percentage of a server's resources (CPU, memory, I/O) that are in active use at any given time. Target utilization guidelines: CPU utilization: target: 60–70% average; maximum: 80% sustained. Reasoning: CPU spikes are unpredictable. At 80% average, any spike pushes to 100% (causing queue buildup, increased response times, and dropped requests). At 65% average, there's meaningful headroom for spikes without degradation. Memory utilization: target: 70–80% in use. Avoid: above 90% (risk of OOM kills and swapping). Note: unlike CPU, memory usage doesn't cause instant degradation — until the system runs out and starts swapping (at which point performance collapses). Disk I/O: SSDs: keep utilization below 70% (throughput drops significantly as SSDs fill up above 75–80% capacity). HDDs: stay below 80% utilization. Network: target: 60–70% of NIC capacity. At 100% network utilization: packet loss, retries, and connection timeouts begin. Common mistakes in utilization targets: too low (30–40% target): wastes money — resources are idle. Appropriate for latency-sensitive real-time systems (payment processing, trading). Too high (90%+): risks service degradation under normal load variation. Cloud autoscaling changes the calculus: with autoscaling (AWS EC2 Auto Scaling, GCP Managed Instance Groups): target 70–80% CPU utilization as the scaling trigger. Auto-add instances when threshold is hit; scale down when load drops. This allows higher average utilization while maintaining headroom. Recommended monitoring: set alerts at 80% CPU (warning) and 90% (critical). Track p99 response times — rising p99 is often the first sign of capacity issues even before CPU maxes out.

Server size by concurrent users

Generated from this calculator. These are planning estimates, not benchmarks; load-test before you commit.

Estimated vCPU, RAM and bandwidth for a web application (10 requests per user per minute, 50 KB responses, 200 ms target, basic N+1 redundancy)
Concurrent usersvCPURAMBandwidthRequests/sec
10012 GB11 Mbps17
50018 GB51 Mbps84
1,000215 GB101 Mbps167
5,000774 GB501 Mbps834
10,00013147 GB1,001 Mbps1,667

Related calculators: Bandwidth and CDN · Database Size · Serverless Cost · API Latency

Key Takeaways

  • Server capacity planning prevents both over-provisioning (wasted cost) and under-provisioning (poor performance)
  • Always include redundancy - N+1 provides 50% extra capacity for failover
  • Different workloads have different bottlenecks: web apps need CPU, databases need RAM and fast storage
  • Plan for peak traffic, not average - your servers must handle traffic spikes
  • Monitor actual usage and adjust - capacity planning is an ongoing process

Understanding Server Capacity Planning

Server Capacity Planning Reference — Requests per Second
Application Type Typical RPS (single server) Memory per Request Recommended CPU Cores Notes
Static file server (nginx)10,000–50,000 RPS~1–5 KB4–8 coresMostly I/O bound; fast
REST API (Node.js/Go)1,000–10,000 RPS~1–10 MB4–8 coresAsync/lightweight
REST API (Python/Flask)100–1,000 RPS~5–50 MB4–8 coresGIL limits concurrency
REST API (Java/Spring)500–5,000 RPS~50–200 MB8–16 coresJVM overhead; scales well
Web app (PHP/WordPress)100–500 RPS~10–50 MB/page4–8 coresDatabase-bound
ML inference (CPU)1–10 RPS~100 MB–2 GB8–32 coresVery resource intensive
ML inference (GPU)10–100 RPS~1–8 GB GPU VRAMGPU requiredDramatically faster than CPU
Database (PostgreSQL)1,000–10,000 QPS~1–10 MB/connection8–32 coresQuery complexity matters greatly
Video streaming100–500 concurrent streams~1–5 Mbps/stream4–8 coresNetwork bandwidth often the bottleneck
Server Sizing Rule of Thumb Reference
Rule Description Formula Notes
CPU target utilizationKeep CPU at 60–70% peak for headroomServers needed = Peak RPS / (Max RPS × 0.65)Never run >80% sustained
Memory headroomProvision 20–30% extra memoryMemory = (Requests × Memory per req) × 1.25Account for OS and caching overhead
Concurrency estimationThread count = (RPS × Average Response Time)Little's Law: L = λ × WL=concurrent users, λ=requests/sec, W=avg response time
N+1 redundancyAlways have spare capacityMinimum servers = calculated + 1Allows maintenance without downtime
Peak traffic multiplierSize for 2–5× average trafficTypical spikes: 2–10× during eventsUse autoscaling for variable load
Storage headroomReserve 20–30% of disk for growthDisk = Data size × 1.3SSDs degrade with high utilization
Network bandwidthCalculate 70% of NIC capacityUsable bandwidth = NIC rate × 0.7Leaves headroom for bursts
Horizontal vs. Vertical Scaling Reference
Factor Vertical Scaling (Scale Up) Horizontal Scaling (Scale Out) Better Choice
What it meansBigger machine (more CPU/RAM)More machinesDepends on use case
Cost at scaleDiminishing returns; expensiveLinear cost scalingHorizontal at large scale
ImplementationChange instance typeAdd instances + load balancerVertical simpler initially
Downtime requiredOften yes (reboot for resize)No (rolling addition)Horizontal
Stateful applicationsEasier (single machine)Complex (session sharing)Vertical
Maximum limitHard ceiling (largest VM)Virtually unlimitedHorizontal
Failure impactSingle point of failureDistributed (redundant)Horizontal
Database scalingVertical often necessary firstRead replicas; then shardingHybrid common
Best forDatabases, legacy apps, simpler architectureWeb/API servers, microservices, high-trafficContext-dependent

Server capacity planning is the process of determining the compute, memory, storage, and network resources required to meet application performance goals. Effective capacity planning balances cost efficiency with the ability to handle peak workloads while maintaining acceptable response times.

Key Factors in Server Sizing

  • Concurrent Users: The maximum number of simultaneous active users your application needs to support
  • Request Rate: How many requests each user generates per minute or second
  • Response Size: The average payload size of server responses affects bandwidth requirements
  • Response Time: Your target latency determines how much parallel processing capacity you need
  • Workload Type: CPU-bound, memory-bound, or I/O-bound workloads have different resource requirements

Capacity Formulas

Requests/Second = Concurrent Users x Requests/User/Minute / 60
Bandwidth = RPS x Response Size x 8 (bits per byte)
CPU Cores = RPS x Processing Time / 1000 x Safety Factor

Workload Type Considerations

Web Applications: Generally CPU-bound with moderate memory needs. Focus on fast response times and session management. Caching can significantly reduce server load.

API Servers: High request rates with small payloads. Optimize for throughput and connection handling. Consider rate limiting and request queuing.

Database Servers: Memory-intensive with high I/O requirements. SSD storage is critical. Memory should be sized to hold working dataset for optimal performance.

Compute Intensive: CPU-bound workloads like video encoding, ML inference. Benefit from high core counts and may need GPU acceleration.

Media Streaming: Bandwidth-intensive with moderate CPU needs. Content delivery networks (CDNs) can offload significant traffic.

Redundancy Strategies

  • No Redundancy: Single point of failure - acceptable only for development or non-critical systems
  • N+1 (Basic): One extra unit for failover - industry standard for most production workloads
  • 2N (High Availability): Full duplicate capacity - for business-critical applications
  • 3N (Mission Critical): Triple redundancy - for financial systems, healthcare, and life-safety applications

Best Practices

  • Start with conservative estimates and scale based on actual metrics
  • Use auto-scaling to handle variable traffic patterns cost-effectively
  • Implement monitoring and alerting before you need it
  • Plan for 3-6 months of growth, not just current needs
  • Consider geographic distribution for global applications
  • Test your capacity assumptions with load testing tools