Size a server to the workload, not the price tier: measure peak load, set RAM, CPU, storage and network separately, add headroom and know when to resize.
The right server size is the smallest configuration that still handles your busiest hour with room to spare. You find it by measuring one workload at its peak, sizing CPU, RAM, storage and network separately, and adding headroom. Picking a plan by name or by price alone is how people end up either paying for idle cores or watching a process get killed for lack of memory. On Servers Are Up you can pick a size per workload across Linux, Windows, containers and game servers, and manage every machine from one browser tab.
This guide walks through the method, then applies it to the four workloads most readers here run: web apps and APIs, game servers, AI projects and Windows desktops.
Plan names (Starter, Standard, Pro) are labels for bundles of CPU, memory and disk. They tell you nothing about whether the bundle matches what you run. Two apps that both "serve a website" can differ tenfold in memory use: a static site behind a cache barely touches RAM, while a Java service with a large heap or a database with a big working set can take most of it on its own.
Undersizing and oversizing both cost money. Too small, and you get slow responses, restarts and outages at the worst moment. Too large, and you pay every month for capacity nobody uses. The goal is a server whose busiest hour lands somewhere in the comfortable middle of its limits. For a deeper look at the forecasting side, our server capacity planning guide covers growth over months rather than a single sizing decision.
Write down four facts before comparing any sizes:
This short brief decides everything that follows. Without it, any number you pick is a guess.
Averages hide the problem. A server averaging 25% CPU over a day may sit at 95% for twenty minutes every afternoon, and those twenty minutes are what your users remember. Capacity guidance consistently recommends recording the metrics that show the limit: response-time percentiles such as P95 and P99, error rate, throughput, and CPU, memory, disk and network use at each load step. Percentiles matter because they show the slowest requests, which averages smooth away.
If you already run the workload somewhere, collect at least a couple of weeks of data that includes your busiest days. If it is new, run a load test that ramps traffic step by step and note where things bend. The same guidance points out that a resource hitting full utilization, errors staying above your threshold, growing P99 latency or throughput that stops rising all mark the capacity limit. Correlate them: if latency climbs exactly when CPU flattens at 100%, CPU is your bottleneck.
Two practical habits help:
A server is four constraints, not one. Any of them can be the limit while the others sit idle, so check each separately.
RAM is the resource that punishes mistakes most. CPU shortage makes things slower. Memory shortage makes things stop: the operating system starts swapping to disk, which is far slower than memory, or kills the biggest process outright.
To estimate RAM, add up what each piece needs at peak:
The signs that you are short on memory are consistent: swap use rising, out-of-memory kills in the system log, and latency that grows with uptime. If you see memory growth that never plateaus, look for a leak before you buy more RAM.
A useful starting method is to run the real workload for a few days, read peak resident memory for every process, add them together, then add a margin on top. Java services deserve special care because the runtime reserves a heap plus memory outside it; our JVM memory guide breaks that down.
CPU needs are about how much work happens at the same time. A single-threaded program cannot use eight cores, so more cores do not help it, while a web server handling many parallel requests scales with core count. Ask two questions: is the workload parallel, and does it have one hot thread? Game servers are the classic example, where one main thread often sets the ceiling and clock speed matters as much as core count.
Watch sustained CPU use at peak. If it sits near full for long stretches, and response times rise at the same moment, you need more compute or a lighter workload. If peak CPU is under half, a smaller size will probably do.
Capacity is simple: operating system, application, data, logs, backups and growth. Logs and backups are the usual surprise, because they grow quietly until the disk fills. Add storage as a separate line item when you need it. On our platform, storage is a paid add-on, for example the 512 GiB standard storage drive, so you can keep the server itself small.
Speed is the part people forget. A database doing many small reads and writes can be limited by disk operations per second long before the disk is full. Look at disk I/O wait during your peak, not just free space.
Network limits show up as bandwidth caps, connection counts and latency. Streaming, file distribution and big game lobbies use bandwidth. APIs with many small calls care more about latency and connection handling. If the machine needs a fixed address, a public IPv4 address is $5 per month on top of the server. Resilience belongs here too: the way you test network redundancy and failover decides whether one link problem becomes an outage. Our guide to virtual network management covers planning and securing the network side.
Headroom is the margin between your measured peak and the server's limit. It absorbs growth, unexpected spikes and the overhead you did not measure. Sizing guidance describes the trade-off plainly: too little margin risks availability, too much wastes budget.
A workable approach:
If you split one big machine into several virtual ones, total every memory allocation and add the host's own overhead before deciding the pool is big enough.
The table maps common workloads to the resource to watch first and the Servers Are Up plan family where they usually live. Treat the starting points as where you begin measuring, not as final answers.
| Workload | Watch first | Starting point |
|---|---|---|
| Small web app or API | RAM, then CPU | Linux Starter, $11 per month |
| Production web app with a database | RAM and disk speed | Linux Standard, $38 per month |
| Heavier services, several apps on one machine | RAM and CPU together | Linux Pro, $76 per month |
| Containerized apps | Per-container memory limits | Docker Starter, $11 per month |
| Kubernetes development | Node memory, scheduling | K8s Dev Cluster, $38 per month |
| Windows workloads | RAM, CPU | Windows Starter, $35 per month |
| Game server | Main-thread CPU, RAM | Game servers from $7.99 per month |
| AI agents | RAM, API calls | Agent Micro, $9 per month |
Start with RAM for the runtime and database, then confirm CPU under a load test. Most web workloads are limited by memory and database speed before raw compute. If you run several small services, containers let you give each one its own limit instead of buying a separate machine for every one. Our Docker Compose linter helps you check a compose file before you deploy it.
Game servers are sized by the game, the player count and any mods. A modded world with many players needs more memory and stronger single-thread performance than a small vanilla one. We publish a RAM, CPU and tickrate sizing guide for 34 multiplayer games, which is the best place to look up your title. Then pick from our game server hosting options.
AI sizing starts with the model. When a model runs on a GPU, the guidance from VMware's AI sizing document says GPU-enabled virtual machines need memory for the operating system and loaded software, and that a properly functioning modern large language model should not swap into VM RAM. It also offers a rule of thumb of two to three times the total GPU memory as server RAM, while noting that overhead and other workloads need their own allowance. For hobbyists running agents that call a model over an API rather than hosting one, the server mostly needs steady memory and a reliable connection. Our CPU vs. GPU explainer helps you decide which one your project needs.
Windows carries a larger baseline than a minimal Linux install, so it needs more memory to do the same job. That is why the Windows tiers start higher: Windows Starter is $35 per month, Standard $66 and Pro $116. If several people will work on one desktop at once, size for the total of their sessions, not one user. The Windows Server desktop is $66 per month.
Resize on evidence, not on a feeling. Signs the server is too small:
Signs it is too big: CPU and memory both stay low even on your busiest day, for weeks. Then step down a tier and keep the savings.
Revisit sizing after any change that alters the load: a new feature, a marketing push, a bigger player base, a larger dataset or a model upgrade. Server uptime also depends on routines around the machine, which we cover in our uptime best practices.
Our view: size small, measure, then grow
We build Servers Are Up around the idea that sizing should be a routine you can repeat, not a bet. Every server, container and network lives in one browser console, so you can open a terminal and a desktop side by side and watch memory and CPU on a machine while you change the thing that is using them.
Because sizing is per unit, you can begin with the tier that fits today's measured peak and move when the numbers say so. Our servers run on hardware we own and operate in the United States, which means the capacity you size against is capacity we manage directly.
For teams, pooled resources fit the same idea: a shared allocation you divide among machines, with an API and an MCP endpoint so your own AI agents can read usage and automate the next step.
— Servers Are Up Engineering
Once you have a measured peak and a margin, the choice is quick. Pick a Linux or Windows server for a single workload, containers for several small services, or a virtual datacenter when you want a pool of resources to divide up: Hobby Lab is $32 per month, Developer Studio $64 and Team Workspace $258. Machines you already run elsewhere can be connected for $3 per month per machine, so one console can show everything.
See every plan and size on Servers Are Up and choose the one that matches your numbers.
It depends on what runs on it, so add up peak memory for the operating system, your application, the database working set and cache, then add a margin. Measure over a couple of weeks that include your busiest period. RAM is the resource to be most generous with, because running out stops processes rather than just slowing them.
Start with the smallest tier that fits the software's stated requirements, then run a load test that ramps up step by step. Watch where latency bends or a resource fills. Move up one tier at a time and repeat the test until the peak sits comfortably below the limit.
It depends on the workload. A single-threaded or tightly coupled program needs one strong machine. Stateless services spread easily across smaller machines or containers, which also lets you scale in small steps. Containers and pooled resources on our platform suit that second case.
If CPU and memory stay low on your busiest days for several weeks, and latency is flat, you are paying for unused capacity. Drop one tier, keep watching the same metrics and confirm the peak still has room.
Explore With AI & Cite This Page
Open a grounded prompt in your AI assistant or copy a clean Markdown, HTML, or APA reference link.
Validate protocols and subnets directly in your browser or continue reading related architecture notes.
Free WHOIS & RDAP Domain & ASN Lookup Tool
SSH Keygen Generator & Cloud-Init YAML Builder
CVE Vulnerability & CISA KEV Banner Advisor
Server Capacity Planning: Little's Law, Queuing Knee Math, Linux PSI Telemetry, and Tier Sizing
Size servers quantitatively using Little's Law, M/M/1 queuing utilization knees, Linux Pressure Stall Information (/proc/pressure), and working-set RAM math.
Game Server Control Panel: What It Does and How to Choose
What a game server control panel does, which features matter, how to set one up and how to choose between panel types, with a browser-based option from $7.99 a month.
Browser-Based SSH Terminal Setup for Multi-Server Access: WebSocket Bastion & Guacamole Architecture
Architectural deep dive into multi-server browser SSH and RDP workspaces: xterm.js WebGL rendering, single-use WebSocket session tickets, loopback guacd multiplexing, and SSH key hygiene.
How to Install Python on Windows 11 & Windows Server 2025: uv, WinGet, MAX_PATH & NSSM Services
Modern 2026 guide to installing and running Python 3.13+ on Windows 11 and Windows Server 2025: Astral uv vs winget + py.exe launcher, PowerShell execution policy, fixing MAX_PATH >260 chars, and deploying 24/7 services via NSSM.