A cached website can serve many requests without running PHP or querying a database, but caching does not remove the need to size the origin correctly. This guide explains how to estimate PHP workers, CPU, RAM, storage, object-cache capacity, and database headroom for a website, then compare hosting tiers against real traffic patterns rather than page-view totals alone.
Overview
The question “How much hosting capacity do I need?” has no useful answer based only on monthly visitors. Two websites with the same traffic can have very different hosting requirements because one may serve most pages from an edge cache while the other sends every request to PHP. A WooCommerce store, membership site, or publishing workflow also creates more uncached work than a mostly static brochure site.
Start with four variables:
- Request rate: Measure peak requests per second or per minute, not just average daily traffic.
- Cache-hit ratio: Separate requests served by a CDN, full-page cache, or server cache from requests that reach the application.
- Request cost: Identify which requests execute PHP, query the database, call external services, or perform background tasks.
- Burst behavior: Allow for launches, campaigns, crawlers, cache purges, and traffic arriving in short spikes.
A high cache-hit ratio usually reduces origin CPU and PHP demand, but it does not make resource limits irrelevant. Cache misses, logged-in sessions, search pages, checkout flows, API requests, scheduled jobs, image processing, backups, and administrative activity still consume capacity. The goal is not to maximize every specification; it is to prevent queueing and memory exhaustion during the busiest credible workload.
For background on choosing disk, memory, Redis, or a managed cache, see Choosing a Cache Storage Strategy for VPS Websites. Keep page caching, object caching, and edge caching distinct: they reduce different kinds of work and require different capacity assumptions.
How to compare options
Hosting plans often use different names for similar limits. One provider may advertise PHP workers, another concurrent processes, and another CPU seconds or application processes. Compare the underlying behavior rather than the label.
1. Build a workload baseline
Collect at least seven days of representative data if possible, including a busy period. Record total requests, cache hits and misses, peak origin requests, average and high-percentile response time, CPU usage, memory usage, database load, and PHP queue time. Logs from the CDN, reverse proxy, web server, PHP runtime, and application should be reconciled because each layer sees a different portion of the workload.
A simple estimate is:
Origin requests per second = peak total requests per second × (1 − cache-hit ratio)
This is only a starting point. If the cache-hit ratio is 95%, a short burst of 200 requests per second can still send about 10 requests per second to the origin. If a request occupies a PHP worker for 500 milliseconds, those requests require roughly five workers just to keep pace, before allowing for variance, background work, and slower database queries.
2. Read resource definitions carefully
Check whether a plan’s advertised RAM includes the operating system, database, control panel, cache services, and file cache. Confirm whether storage is shared, whether CPU is dedicated or burstable, and whether limits apply per site, account, container, or server. Also check what happens when a limit is reached: requests may queue, slow down, be terminated, or be throttled.
3. Compare capacity at the bottleneck
The smallest effective limit usually controls performance. Extra disk space cannot compensate for too few PHP workers. More PHP workers cannot fix a database that is locked or starved of memory. A large Redis allocation is not useful if the application does not use object caching efficiently. Compare the full resource path: DNS and CDN, web server, page cache, PHP workers, database, object cache, storage, and background jobs.
| Workload pattern | Primary capacity concern | What to verify |
|---|---|---|
| Mostly public, cacheable pages | Cache effectiveness and burst handling | Origin requests after purge, cache-hit ratio, CDN limits |
| Plugin-heavy WordPress site | PHP execution and memory | Worker count, per-process memory, slow plugins, queue time |
| WooCommerce or membership site | Dynamic requests and database load | Cart, checkout, account, search, sessions, and admin activity |
| API or application server | Concurrency and downstream services | Connection pools, worker time, rate limits, and error handling |
| Media or content-heavy site | Storage, transfer, and image processing | Disk growth, inode usage, backups, and object storage options |
Feature-by-feature breakdown
PHP workers
PHP workers process dynamic requests. If all workers are busy, new requests wait even when CPU appears available. Estimate demand from peak uncached requests and the time each request occupies a worker. Use headroom rather than sizing to the exact average. Long-running requests, slow third-party calls, and uncached searches can consume workers disproportionately.
More workers are not automatically better. Each worker may require substantial memory, and setting the count too high can cause swapping or process termination. Tune worker limits alongside per-process memory and observe queue time under a controlled load.
RAM
RAM must cover the operating system, web server, PHP processes, database buffers, object cache, control tools, and temporary spikes. A practical worksheet separates fixed and variable use:
- Fixed allocation: operating system, services, monitoring, and management software.
- Application allocation: PHP workers multiplied by observed or configured per-worker memory.
- Database allocation: database process, buffers, connections, and temporary operations.
- Cache allocation: Redis object cache, in-memory page cache, and filesystem cache where applicable.
- Safety margin: capacity for bursts, deployments, imports, backups, and memory fragmentation.
Do not treat “available” memory in a dashboard as a complete diagnosis. Review swap activity, process-level usage, out-of-memory events, and the timing of slowdowns. A cache that consumes all remaining memory can make the application less reliable.
CPU
CPU demand depends on code complexity, compression, image work, encryption, database queries, and cache misses. A site with modest traffic can still need significant CPU if each request performs expensive work. Compare sustained utilization with short peaks, and look for throttling or CPU steal time on virtual servers.
Storage and cache capacity
Storage includes the application, uploads, logs, temporary files, backups, database files, and cache objects. Set a growth estimate and reserve room for deployments and backup rotation. A full filesystem can break logging, sessions, database writes, and cache operations before the site visibly fails.
Disk page caches are inexpensive but may be slower than memory. Redis object caching can reduce repeated database work, but its memory allocation should reflect the working set and eviction policy. Page cache and object cache solve different problems; read How to Monitor Cache Hit Ratio before changing cache capacity based on assumptions.
Database workload
Measure query volume, slow queries, lock waits, connection usage, and database size. A full-page cache can hide database inefficiency until a purge, product update, logged-in request, or traffic spike exposes it. Search, filtering, reporting, order processing, and imports often create heavier database work than ordinary page views.
Cache policy and invalidation
Capacity planning must include what happens when cached content expires or is purged. A short TTL increases origin work; a long TTL can complicate freshness. Incorrect cache keys can reduce the hit ratio or serve the wrong variation. The CDN cache keys guide provides a useful review point before interpreting cache metrics.
Best fit by scenario
Small brochure or documentation site: Prioritize reliable page and edge caching, sufficient storage, automated updates, and monitoring. PHP capacity can be modest if public pages remain cacheable, but test cache purges and contact forms.
Content site with traffic spikes: Choose a setup with effective CDN delivery, predictable origin limits, and enough PHP and database headroom for cache misses after publishing or purging. Test a cold-cache scenario, not only a warmed page.
Plugin-heavy WordPress installation: Favor transparent PHP worker and memory limits, staging access, slow-request visibility, and a cache configuration compatible with the plugins. Avoid judging a plan by storage alone.
WooCommerce, membership, or personalized site: Assume a lower effective cache-hit ratio because carts, accounts, sessions, and checkout are dynamic. Give greater weight to database performance, connection limits, PHP concurrency, object caching, and operational support.
VPS or cloud deployment: Use a sizing worksheet that includes the operating system and every service you will operate. Nginx FastCGI Cache, Varnish, Redis, and a CDN can work together, but each adds configuration and invalidation responsibilities. Review the cache configuration matrix before adding another layer.
Managed WordPress hosting: Compare the practical limits, not only the number of websites or visits included. Ask how PHP workers, memory, staging, backups, cache exclusions, and overage behavior are defined. A managed service may reduce operational work, while a VPS may provide more control; the better fit depends on workload and team capacity. See Managed WordPress Hosting vs VPS for the broader trade-off.
When to revisit
Recalculate capacity before a marketing campaign, seasonal event, major release, cache-policy change, platform migration, or hosting renewal. Revisit it after adding plugins, changing themes, enabling personalization, moving a database, or introducing background imports and integrations.
Use this practical worksheet:
- Record peak total requests and peak origin requests.
- Measure cache-hit ratio separately for CDN, page cache, and object cache.
- Measure PHP execution time, worker queue time, and peak concurrent workers.
- Record CPU, RAM, swap, database connections, slow queries, and storage growth.
- Test warm-cache and cold-cache traffic, including dynamic and logged-in paths.
- Compare the results with the host’s actual limits and documented enforcement behavior.
- Repeat the test after a change and keep the results with your deployment records.
Review benchmark assumptions at least twice a year and whenever providers change plan limits, features, pricing, or policies. A hosting performance benchmark template can make comparisons repeatable, while the migration performance checklist helps confirm that a new host improves actual response times rather than only advertised capacity.
The right hosting tier is the one that keeps the uncached workload responsive during realistic bursts, preserves memory and database headroom, and remains understandable when the site changes. Size from measured bottlenecks, validate the cache assumptions, and leave room for the next operational event—not just the average day.