“How much RAM do I need?” is the single most expensive question in Windows VPS planning. Over-specify and you pay every month for idle cores; under-specify and SQL Server starts paging to disk, IIS request queues climb, and every user blames the hosting provider. This guide is a sizing reference: it maps the four most common Windows Server workloads — IIS and .NET, SQL Server, Active Directory, and Remote Desktop Services — to concrete vCPU and RAM figures, with the reasoning behind each number.
Sizing starts with the workload, not the price. If you are still deciding whether you need a Windows host at all, start from the Windows VPS platform overview and come back here with a workload in mind.
The three numbers that matter: vCPU, RAM, and disk latency
vCPU is the easiest resource to oversell and the hardest to measure. A “4 vCPU” plan on an oversubscribed host can behave like a single core under contention. RAM is the opposite: you can measure exactly what a workload holds, and Windows will use every gigabyte you give it. Disk is the quiet third axis — a SQL Server with plenty of RAM but 200 IOPS of shared storage still crawls during a checkpoint.
- vCPU — size to peak concurrent CPU, not average. Plan for 30–50% sustained headroom so a single spike does not queue.
- RAM — the primary lever. A Windows Server 2022 instance idles at roughly 1.0–1.5 GB. Add the workload’s working set on top.
- Storage — demand SSD or NVMe. Guest-level latency above 10 ms shows up as application stalls long before the disk looks full.
Workload sizing reference table
Use these figures as a starting point, then measure for two weeks before committing to a larger plan. Each row assumes a single Windows Server 2019 or 2022 guest with no other roles installed.
| Workload | vCPU | RAM | Storage | Notes |
|---|---|---|---|---|
| Low-traffic IIS site (static, under 50k hits/day) | 2 | 4 GB | 60 GB SSD | Worker process plus two or three app pools; leave room for Windows Update. |
| ASP.NET or .NET Core API, moderate traffic | 4 | 8 GB | 100 GB NVMe | Roughly 1 GB per four to six concurrent app pool working sets. |
| IIS plus SQL Server, small line-of-business app | 4–8 | 16 GB | 200 GB NVMe | Cap SQL with max server memory at 70% so IIS keeps its headroom. |
| SQL Server standalone, production OLTP | 4 | 16 GB | 250 GB NVMe | Minimum sensible production floor; below 16 GB buffer cache pressure dominates. |
| SQL Server, 50–200 GB database | 8 | 32 GB | 500 GB NVMe | Put tempdb on its own volume where the provider allows it. |
| Active Directory domain controller | 2 | 4 GB | 80 GB SSD | Comfortable to about 500 users; AD is light, DNS and replication dominate. |
| File and print plus AD role combination | 2–4 | 8 GB | 150 GB | Add roughly 2 GB per 100 GB of actively served file data for caching. |
| RDS session host, 10–15 light users | 4 | 16 GB | 150 GB NVMe | Budget 1–1.5 GB per concurrent user for Office and a browser. |
| RDS session host, 25 Office-heavy users | 8 | 32 GB | 250 GB NVMe | Outlook alone can hold 400–800 MB per user. |
| Build or CI agent (.NET, MSBuild) | 4–8 | 16 GB | 200 GB NVMe | MSBuild and NuGet restore are bursty; leave core headroom. |
Sizing IIS and .NET applications
IIS itself is cheap; the application pool working sets are what you size for. A useful starting formula: RAM = 1.5 GB for the OS + (concurrent app pool working sets × average working set) + 1 GB margin. A typical ASP.NET Core service holds 150–300 MB per app pool under load; a legacy ASP.NET MVC app with heavy caching can hold 500 MB or more.
# See which app pools are actually holding memory
Get-Process -Name w3wp |
Select-Object Id, @{n='PoolMB';e={[math]::Round($_.WorkingSet64/1MB)}}, StartTime
# Map process to app pool
Import-Module WebAdministration
Get-IISAppPool | Select-Object Name, State, ProcessModel.Id
If you can only add one resource, add RAM before vCPU for IIS. Thread-pool starvation is usually a symptom of garbage collection pressure caused by a small heap, not insufficient cores. Enable gcServer in runtimeconfig.json for throughput-oriented .NET Core APIs, and treat an app pool private memory limit as a safety valve, never as a sizing tool.
Sizing SQL Server
SQL Server consumes all available memory for buffer cache unless you stop it, which is why an unbounded instance on a shared VPS eventually starves every other role. Cap it explicitly:
-- Leave at least 4 GB (or 20%) for the OS and other roles
EXEC sp_configure 'show advanced options', 1; RECONFIGURE;
EXEC sp_configure 'max server memory (MB)', 12288; RECONFIGURE; -- 12 GB of a 16 GB box
-- Baseline: how much buffer cache is actually in use
SELECT object_name, counter_name, cntr_value
FROM sys.dm_os_performance_counters
WHERE counter_name IN ('Page life expectancy','Buffer cache hit ratio','Page reads/sec');
Page Life Expectancy below 300 seconds is the classic signal that you are short on RAM. For CPU, count cores the way SQL does: four physical cores present eight logical schedulers under hyper-threading. A workable heuristic is 2–4 active cores per 100 concurrent OLTP connections, with MAXDOP set to the number of physical cores up to eight.
Sizing Active Directory
AD is the least demanding Windows Server role and the one people most often over-provision. A domain controller for up to 500 users runs comfortably on 2 vCPU and 4 GB RAM. The exceptions that push you to 4 vCPU and 8 GB are heavy DNS query volume, additional roles such as Certificate Services, or more than about 2,000 objects with frequent LDAP searches.
- Place
NTDS.ditand its transaction logs on separate virtual disks if the provider allows it; a single busy volume causes checkpoint stalls that users perceive as slow logons. - Never size a DC at 2 GB “just in case” — Domain Services, DNS, and the OS will consume it and event log shipping will start failing.
- For two DCs in a VPS environment, run them on separate physical nodes so a hypervisor maintenance event cannot take both down at once.
Sizing Remote Desktop Services
RDS is the workload where per-user sizing is unavoidable and where storage IOPS decides user satisfaction. Plan for these per-session memory budgets, then add 2 GB for the OS and 1–2 GB for the RDS role services.
| User profile | RAM per session | Notes |
|---|---|---|
| Single business app, text-based | 300–500 MB | Thin-client style workloads. |
| Office plus browser, light use | 1.0–1.5 GB | The common small-business case. |
| Office plus browser plus heavy Excel macros | 1.5–2.5 GB | Excel can hold hundreds of MB per open workbook. |
| CAD or engineering application | 3–6 GB | Move to dedicated session hosts or a GPU-backed VM. |
So 15 light users implies 16 GB, and 25 Office-heavy users implies 32 GB. RDS sessions are bursty on CPU, and 4 vCPU per 10–15 light users is a reasonable starting ratio. Watch logon storms rather than steady state: simultaneous morning logons, profile loading, and Group Policy processing produce the peak that actually queues.
A practical sizing workflow
- List the roles you will actually install, not the ones you might.
- Pick the largest matching row from the reference table and add per-role deltas.
- Deploy one tier smaller where vertical resize is available, then measure.
- Watch Memory Available, Pages/sec, processor queue length, and disk queue length for two weeks.
- Resize once, based on the peak you recorded.
The most common mistake is buying for average load and living with the peaks. The second is treating vCPU as the only lever when RAM and disk latency usually matter more for Windows workloads. Record your figures, revisit them after every major application change, and sizing stops being guesswork.


