Website Hosting Migration Performance Checklist: Benchmarking Before and After a Host Change
Web HostingPerformance BenchmarksMigrationTTFBUptime

Website Hosting Migration Performance Checklist: Benchmarking Before and After a Host Change

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

Use this repeatable hosting migration checklist to compare TTFB, caching, capacity, DNS, reliability, and load performance before and after a host change.

A host migration should be measured, not assumed to be faster. This website hosting migration checklist gives you a repeatable before-and-after process for comparing TTFB, cache behavior, application capacity, DNS performance, database response, image delivery, uptime, and realistic load handling.

Overview

Changing web hosting can improve website speed, reliability, and operating headroom, but a new server is not automatically a faster server. Results depend on location, traffic patterns, caching, software configuration, database workload, page design, and the way the test is performed.

The safest approach is to establish a baseline before migration, reproduce the same tests after migration, and separate hosting-related changes from unrelated site changes. Record the page URLs, test regions, device profiles, time windows, cache state, traffic volume, and software versions used in each measurement. Without that context, two numbers may look comparable while describing different conditions.

Use this checklist for a planned migration, a hosting comparison, a renewal decision, a scaling review, or a quarterly performance audit. It is particularly useful for WordPress sites, ecommerce stores, and applications that rely on PHP workers, database queries, server caching, or a CDN.

Define success before testing

  • Choose the pages and transactions that matter: homepage, representative content page, search, login, checkout, product page, and a high-traffic landing page.
  • Set practical goals for response time, uptime, error rate, cache-hit behavior, and capacity under expected traffic.
  • Decide which variables must remain unchanged, including CDN configuration, DNS provider, image files, plugins, application code, and database contents.
  • Record the current host, server region, protocol support, PHP or runtime version, web server, database version, and caching layers.

Checklist by scenario

1. Before the migration: build a baseline

Run several measurements rather than relying on one speed test. Test from locations that represent your visitors and include both a warm-cache request and a cold-cache request where safe. A warm request shows the experience for a cache hit; a cold request reveals more about origin processing, database work, and application startup.

  • TTFB: Record time to first byte for cached and uncached pages. Note whether the result is measured at the origin or through the CDN.
  • Core Web Vitals: Capture the relevant loading, interaction, and visual stability measurements for key templates. Treat these as field or lab observations with their test conditions attached.
  • Cache status: Record response headers such as Cache-Control, Age, and any CDN or server cache status. Confirm the TTL and whether cookies, query strings, or authorization bypass caching.
  • Server resources: Record CPU, memory, disk usage, disk I/O, PHP or application worker utilization, worker queueing, and process limits during normal traffic.
  • Database: Measure typical query latency, slow-query activity, connection usage, and database resource consumption where your monitoring allows it.
  • DNS and delivery: Record DNS lookup behavior, authoritative nameserver configuration, TLS negotiation, compression, image formats, and CDN response times.
  • Reliability: Export recent uptime, HTTP error, timeout, restart, and deployment records. Keep the measurement window and monitoring location consistent.

Save the results in a simple table with columns for date, URL, region, device, cache state, TTFB, page-load observations, status code, and notes. A screenshot without test conditions is difficult to use later.

2. During migration: preserve the variables that matter

Create a staging or temporary hostname and test the new environment before changing production DNS. Verify that the application, database, media files, scheduled tasks, redirects, certificates, email dependencies, and administrative access work as expected.

  • Match the production runtime and web server settings unless the migration explicitly includes an upgrade.
  • Confirm that page caching, object caching, and CDN caching are separate and correctly configured. A page cache serves a rendered response; an object cache, such as Redis, stores reusable application data; an edge cache serves content closer to visitors.
  • Check cache bypasses for logged-in users, carts, checkout, account pages, personalized content, and API responses.
  • Warm important caches in a controlled way, but do not report warmed results as representative of every visitor.
  • Use a low-risk DNS cutover plan with a rollback path. For related DNS and edge considerations, see the CDN migration checklist.

3. After the migration: repeat the same benchmark

Run the same URLs, regions, tools, cache states, and test sequence used for the baseline. Do not change the CDN, cache plugin, image pipeline, theme, or application code at the same time unless you label the result as a combined change.

Compare median behavior across multiple runs instead of selecting the fastest result. Check both performance and correctness: a low TTFB is not useful if pages are stale, sessions break, checkout fails, or cache rules expose private data. Compare origin response time separately from full-page rendering and asset delivery so you can identify where the change occurred.

4. Under expected load: test capacity, not just speed

A fast isolated request does not prove that a host will remain responsive during a campaign or traffic spike. Use a controlled load test against a staging environment or an agreed production-safe target. Start below expected peak traffic, increase gradually, and define stop conditions for errors, latency, CPU, memory, or database saturation.

Record requests per second, response-time distribution, HTTP errors, timeouts, queue depth, worker exhaustion, database connections, and cache-hit ratio. Test cache hits and cache misses separately. Never include checkout, account, or other state-changing actions in a load test without carefully designed test data and safeguards.

What to double-check

  • Cache-hit ratio: A high hit ratio may reduce origin work, but confirm that the cached content is appropriate and invalidates when content changes. Review the practical guidance on Cache-Control headers and TTL settings.
  • Worker capacity: More CPU does not compensate for a small PHP or application worker pool. Look for queueing, max-worker limits, and slow requests that occupy workers.
  • Page cache versus object cache: A page cache can improve anonymous page delivery, while an object cache can reduce repeated database or application work. They address different bottlenecks; one does not automatically replace the other.
  • DNS performance: Test the actual visitor path, including DNS lookup, connection, TLS, CDN routing, and origin response. A faster origin may not change the user experience if delivery or DNS remains slow.
  • Images and static files: Compare compression, responsive sizing, cache headers, transfer size, and CDN behavior. A migration can accidentally disable long-lived asset caching or change image processing.
  • Application correctness: Check redirects, canonical URLs, cookies, sessions, webhooks, cron jobs, search, forms, payments, and background tasks.
  • Cache safety: Confirm that private responses are not stored or served to another user. Review the site’s cache rules before enabling aggressive caching for dynamic pages.

For a deeper diagnosis of slow responses, use the TTFB and Core Web Vitals troubleshooting checklist. If your site uses WordPress ecommerce, also verify the safe exclusions described in the WooCommerce caching guide.

Common mistakes

  • Testing only the homepage: A homepage may be cached while search, product, account, or checkout pages expose the real bottleneck.
  • Comparing different cache states: Compare cold with cold and warm with warm. Label every request clearly.
  • Changing several systems at once: A host migration combined with a CDN change, plugin replacement, and image redesign cannot produce a clean hosting comparison.
  • Using one synthetic result as proof: Test variation is normal. Look for patterns across repeated runs and locations.
  • Ignoring traffic and geography: A host can perform well near its data center and poorly for a different audience. Include representative regions.
  • Optimizing only TTFB: Origin response is important, but images, JavaScript, layout shifts, interaction work, and third-party services can dominate the visitor experience.
  • Load testing production carelessly: Uncontrolled tests can trigger rate limits, fill logs, affect real users, or create orders and notifications.
  • Failing to plan rollback: Keep the old environment available until DNS, application behavior, monitoring, and performance results are verified.

When to revisit

Revisit this checklist before a seasonal planning cycle, a major campaign, a hosting renewal, a traffic increase, or a significant application release. Repeat it after changing the CDN, DNS provider, cache plugin, server software, database configuration, runtime version, or image delivery pipeline. These changes can alter results even when the host remains the same.

Make the process part of a quarterly performance review or another interval that matches your release and traffic patterns. Keep the previous benchmark alongside the new one, document what changed, and record whether the result came from hosting, caching, application code, content, or test conditions.

Practical next step: create a benchmark sheet today with five representative URLs, two cache states, two visitor regions, and fields for TTFB, cache status, worker usage, database latency, DNS behavior, errors, and uptime. Run it before migration, repeat it after stabilization, and approve the change only when speed, capacity, reliability, and application correctness all meet your stated goals.

Related Topics

#Web Hosting#Performance Benchmarks#Migration#TTFB#Uptime
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.