Game Server Sizing Limits at 50, 100 and 200 Players: Where CPU, RAM and NVMe Run Out

At 50 concurrent players a survival server needs roughly 2.5 GHz of genuinely available single-core performance, 6–8 GB of resident memory and sub-1 ms NVMe write latency. At 100 players the memory figure roughly doubles while the CPU requirement grows by only 20%. At 200 players storage and memory bandwidth become the limits before the CPU does. Those three inflection points — not a vendor’s “recommended” column — are what this sizing model maps.

The common mistake is scaling every resource linearly with player count. Game servers do not scale that way: the tick loop is largely fixed-cost, entity simulation grows superlinearly, and storage pressure grows with the rate of change rather than the number of connected clients. If you would rather buy against published sizing, compare dedicated game server plans that list core count, memory and NVMe separately rather than bundling them into a “plan level.”

The Four Budgets That Decide Player Capacity

Every game server consumes four budgets simultaneously: single-core CPU time per tick, resident memory for loaded chunks and entities, random-write IOPS during saves, and outbound bandwidth per player. Capacity is determined by whichever budget closes first, and the identity of the binding budget changes as you add players. A 20-player server is usually bandwidth- and memory-bound on a VPS; a 200-player server is memory-bandwidth and storage-latency bound on bare metal.

Model each budget separately and record the player count at which each one hits 80% utilisation. That 80% line is your practical ceiling, because the remaining 20% is the burst headroom that absorbs a raid night, a mod update or a world save that collides with a player stampede.

CPU at 50, 100 and 200 Players

The tick loop’s fixed cost dominates the first fifty players. A vanilla survival server at 50 players typically consumes 40–60% of one modern core at 3.9 GHz sustained, which means a 4-core, 3.6 GHz box is adequate and a 5.5 GHz boost clock is irrelevant. What matters is that the core is not shared, so a burstable vCPU with a 20% steal time is not adequate even though it benchmarks well in an idle test.

Between 50 and 100 players the added cost is mostly entity AI and chunk loading, both of which are still single-threaded in most titles. Expect 70–90% of one core and a second core handling async chunk generation. At 200 players, with several hundred entities active, you should plan on one full core saturated plus two to three supporting cores, and you should expect tick times to rise even on excellent hardware. If a provider sells you “8 cores, so 8× the players,” that is a misunderstanding of the workload.

Memory: Where the Multiplier Actually Sits

Resident memory scales faster than player count because each connected player keeps chunks loaded and entity state resident. Roughly 40–60 MB per active player for a modded survival server and 15–25 MB for vanilla gives you the working set: about 2–3 GB at 50 players, 5–8 GB at 100, and 12–20 GB at 200 before the JVM or server heap overhead.

The practical recommendation is to double the calculated working set and then check the channel count. A 200-player modded server wants 32 GB in at least four channels, because memory bandwidth becomes the second binding constraint once the heap grows past 16 GB and garbage collection touches it continuously. Capacity without bandwidth produces a box that shows free memory in `free -m` and still stutters.

Storage: Save Cycles Are the Hidden Spike

Storage pressure comes from saves, not concurrency. A 200-player server with a 6 GB world writing a full save every ten minutes produces roughly 36 GB of writes per hour, most of it small random writes. On a consumer SSD with a small SLC cache, that workload exhausts the cache in minutes and drops to 100–200 MB/s with 5–10 ms latency — visible as a save stall that freezes every player on the server.

Two mitigations matter. First, NVMe with datacenter endurance (1 DWPD or better) and QD1 write latency under 0.5 ms. Second, separate the save volume from the OS and logs so a snapshot or log rotation does not collide with a world save. At 50 players, a mirrored SATA SSD pair is adequate; at 200, plan on NVMe.

Bandwidth: 1 Gbps Is Enough Until It Is Not

Steady-state bandwidth is modest: roughly 30–80 kbps per player for most survival and sandbox titles, which is 2–8 Mbps at 100 players and 16 Mbps at 200. The 1 Gbps port is not the constraint on a normal day. The constraint appears during a modpack rollout or a client patch, when every connected player pulls several hundred megabytes at once.

Size the port for the burst, not the steady state: 100 players each pulling a 400 MB update means 40 GB of egress in a ten-minute window, which is roughly 530 Mbps sustained. A 1 Gbps commit handles it; a 100 Mbps commit that advertises “unmetered” does not. Check the committed rate and whether game traffic is excluded from any monthly cap.

Putting the Three Counts Together

Component50 players100 players200 players
Sustained single-core clock≥ 3.6 GHz≥ 3.8 GHz≥ 4.0 GHz, unshared
Useful cores2–446–8
Memory (modded working set)6–8 GB12–16 GB32 GB, 4+ channels
StorageMirrored SATA SSDNVMe, 1 DWPDNVMe, QD1 < 0.5 ms
Committed bandwidth200 Mbps500 Mbps≥ 1 Gbps
Binding constraintMemoryCPUMemory bandwidth

Read the bottom row first. At 50 players, memory is usually the first wall; at 100 players the single-core tick loop; at 200 players it is memory bandwidth and storage latency together. Buying more cores to solve a 100-player problem wastes money, and buying more RAM to solve a 200-player problem does not address the tick loop that is actually saturated.

How to Validate the Model Before You Buy

Run a staged load test: 25, 50, 100 and 200 synthetic or real clients while recording `mpstat -P ALL 1`, `vmstat 1`, `iostat -x 1` and tick-time metrics from the server itself. Plot each of the four budgets against player count and find the 80% crossover for each. That exercise takes an evening and replaces every vendor claim with your own curve.

Keep the resulting chart as a permanent artifact. When the community grows by 30%, you can read the curve instead of guessing, and when a provider offers a cheap upgrade you can decide against numbers. For hosts published with per-component specs rather than bundle levels, see the full hardware specs and pricing and map your curve onto their actual hardware rather than their marketing tiers.

The Sizing Rule That Outlasts the Game Version

Every title’s numbers shift with a major update, but the shape of the curve does not: fixed tick cost, superlinear entity cost, and bursty storage. Size against the curve rather than a single version’s benchmark and you will still be roughly right after the next content patch.

Concretely: at 50 players, get 16 GB of memory in four channels even though you need 8, because memory binds first. At 100, prioritise a 4.0 GHz sustained core over extra cores or capacity. At 200, prioritise NVMe latency and memory bandwidth over raw capacity. Those three decisions cover most of the cost, and all three are visible on a spec sheet if the host lists the details instead of plan names.

Leave a Reply