Website Hosting Performance Benchmark Template: How to Compare Hosts Before Migrating
Web HostingPerformance TestingBenchmarkingMigrationTTFB

Website Hosting Performance Benchmark Template: How to Compare Hosts Before Migrating

CCaching.website Editorial Team
2026-11-12
7 min read

Use this repeatable worksheet to compare hosting speed, caching, TTFB, Core Web Vitals, limits, and reliability before and after migration.

A fair hosting comparison requires more than running one speed test and choosing the lowest number. This benchmark template gives you a repeatable way to compare hosts before a migration by recording origin response times, cached and uncached behavior, Core Web Vitals, uptime, concurrency, database performance, resource limits, and cache hit results under controlled conditions.

Overview

Hosting performance is a system property, not a single server specification. A website may respond quickly from a nearby test location while performing poorly for visitors farther away, authenticated users, uncached pages, or traffic spikes. Conversely, a host that appears slower on an uncached request may deliver excellent visitor performance when its page cache, CDN, and database configuration are working as intended.

Use this benchmark before signing up for a new plan, during a renewal review, before a major campaign, and after a migration. Test the same site or a representative staging copy on each host, using the same content, software version, DNS setup where possible, cache state, geographic locations, and test schedule.

Keep the results in a dated worksheet. A useful row includes:

  • Host, plan, region, server stack, PHP or runtime version, and database version.
  • Test URL, page type, logged-in state, device profile, and geographic test location.
  • Cache state: cold, warm, bypassed, or served through a CDN or edge cache.
  • Test date, test tool, number of runs, median result, and notable errors.

For background on comparing a managed platform with a self-managed environment, see Managed WordPress Hosting vs VPS. The right choice depends on the workload, operational control, and consistency you need—not just a headline speed result.

What to track

1. Time to first byte and total response time

Measure TTFB for at least three states: an uncached public page, a warm cached page, and a dynamic or personalized request that must reach the application. Record several runs and use the median rather than the fastest result. Also record total document response time, because a fast first byte does not guarantee that the complete HTML response is delivered quickly.

Use command-line requests or a browser-based testing tool for repeatability. Inspect response headers for cache status, age, server timing, and cache-control directives. A result marked as a cache hit is not comparable with an origin request. Label every result clearly.

2. Cache behavior

Test whether the expected cache layers are actually serving traffic. Record cache hits and misses at the page cache, reverse proxy, CDN, and object-cache layers where applicable. Check whether a second request becomes faster after warming the cache, and whether content is invalidated correctly after an edit.

For WordPress, test a public page, an uncached preview or preview-like request, a search page, and any important commerce path. Do not include checkout, account, cart, or other personalized pages in a public page-cache test. The WooCommerce caching setup guide explains why these exclusions matter.

3. Core Web Vitals and browser performance

Measure real browser loading, not only server response. Track the current Core Web Vitals reported by your chosen tool, along with page weight, request count, render-blocking resources, image behavior, and layout shifts. Test representative templates such as a homepage, article, product page, category page, and landing page.

Run both mobile and desktop profiles. Keep the page design and third-party scripts identical between hosts; otherwise, you are measuring a site change rather than a hosting change.

4. Concurrent requests and resource limits

Use a controlled load test against staging or a low-risk endpoint. Increase concurrency gradually and record latency, error rate, throughput, and the point at which performance becomes unstable. Never treat a short load test as proof of unlimited capacity.

Record plan limits that can affect the result: CPU allocation, memory, PHP workers, process limits, storage type, bandwidth rules, database connections, inode limits, and any throttling behavior. Ask the provider how overages, resource contention, backups, and traffic spikes are handled, then verify what you can through the control panel or server metrics.

5. Database and application response

Test a page that performs representative database work, not only a static document. Record query count, slow-query warnings, application execution time, and database connection errors where your tooling exposes them. If the platform supports a Redis object cache, compare cold and warm application requests, but keep page cache and object cache results separate. They solve different problems.

For a deeper comparison of cache layers, use Redis Object Cache vs Varnish vs Nginx FastCGI Cache. The benchmark should identify which layer produced each improvement.

6. Availability and operational signals

Track successful checks, timeout frequency, HTTP error codes, DNS lookup time, TLS negotiation time, and periods of maintenance or degraded service. A speed advantage is less useful if the application is difficult to recover or regularly reaches its limits. Record incidents alongside benchmark results so that a one-time outage is not confused with a normal performance trend.

Cadence and checkpoints

Run a baseline before migration, then repeat the same test after DNS changes have settled and caches have been warmed. Take another comparison after importing production data, enabling plugins, changing CDN rules, or moving to a different server region.

A practical recurring schedule is:

  • Monthly: check uptime, TTFB, cache-hit behavior, resource usage, and one representative browser test.
  • Quarterly: repeat the full page, database, concurrency, and Core Web Vitals review.
  • Before a campaign: test the busiest landing page, origin capacity, cache warming, and purge or invalidation procedures.
  • After a change: compare before-and-after results using the same URL, tool, location, and cache state.

Save raw results, not only averages. A dated folder containing screenshots, exported reports, response headers, load-test settings, and server metrics makes later investigations much easier. If cache rules change, document the cache key and TTL assumptions; the CDN cache keys guide covers common causes of unexpected misses or incorrect cached content.

How to interpret changes

Look for patterns across repeated tests rather than reacting to one result. If uncached TTFB worsens while cached delivery remains stable, investigate origin CPU, database work, PHP workers, application changes, or network distance. If both cached and uncached results worsen, check the CDN, DNS, TLS path, cache configuration, and test location.

If response time is stable but Core Web Vitals decline, the cause may be front-end changes such as larger images, new scripts, fonts, ads, or layout changes. If only concurrent tests fail, review worker limits, connection pools, memory pressure, and provider throttling. An increase in cache misses may indicate a changed query string, cookie, host header, cache key, or purge rule rather than a slower server.

Compare medians and distributions where possible. A host with a slightly better median but frequent high-latency outliers may be less suitable than one with more consistent results. Also separate performance from operational fit: support quality, deployment access, backups, staging, security controls, and recovery procedures belong in the hosting decision even when they do not appear in a speed score.

When to revisit

Revisit this benchmark monthly for lightweight monitoring and quarterly for a fuller hosting comparison. Repeat it immediately before a high-traffic event, at contract renewal, after a migration, or when visitors report slowness. Update the worksheet when your hosting plan limits, web server stack, CDN configuration, cache plugin, runtime, database, or measurement tools change.

When migrating, pair this process with the website hosting migration performance checklist. First capture the baseline, then reproduce it on the destination, and finally validate the live site after DNS and caches have stabilized. For each difference, write down a likely cause and a next test instead of assuming that the host alone is responsible.

To act on the results, choose the largest repeatable bottleneck: origin TTFB, cache misses, database work, front-end weight, concurrency limits, or availability. Change one major variable, rerun the same worksheet, and keep the result with the date and configuration. Review the methodology at least every six months so that new browser metrics, server stacks, cache layers, or business-critical page types are not omitted.

Related Topics

#Web Hosting#Performance Testing#Benchmarking#Migration#TTFB
C

Caching.website Editorial Team

Senior SEO Editor

Senior editor and content strategist. Writing about technology, design, and the future of digital media. Follow along for deep dives into the industry's moving parts.