CDN Migration Checklist: How to Move a Website Without Breaking Caching or Traffic
Moving a website to a new CDN is more than changing nameservers or a DNS record. This checklist helps you prepare the origin, reproduce cache and security behavior, verify TLS and redirects, stage the cutover, and monitor the result so visitors can continue reaching a correct and responsive site.
Overview
A CDN migration changes the path between visitors and your web server. That path can include DNS resolution, TLS termination, edge rules, cache keys, compression, redirects, web application firewall settings, and connections to the origin. A configuration that looks equivalent in a dashboard may still behave differently at the edge.
The safest approach is a phased migration rather than a single switch. First document the current setup. Then configure and test the new CDN without sending production traffic through it. After that, make a controlled DNS change, observe real requests, and keep the old configuration available until the new path is proven stable.
Before starting, record the production hostnames, DNS records, origin addresses, supported protocols, certificate coverage, redirect rules, cache policies, purge procedures, and monitoring locations. Include less visible traffic such as API endpoints, webhooks, image subdomains, downloads, staging exclusions, and administrative paths.
It also helps to distinguish the layers involved in website caching. A CDN edge cache stores responses close to visitors, while an origin may use page caching, Redis object cache, Varnish, or Nginx FastCGI cache. Changing the CDN does not automatically change those origin layers, but it can expose differences in cache status, purge timing, or cache-control handling.
What to track
1. DNS and hostname inventory
List every hostname that will move and classify its DNS record. Separate web traffic from mail, verification records, third-party services, and records that must not be routed through the CDN. Confirm whether the new provider expects a CNAME, an address record, delegated nameservers, or another integration method.
Capture the current TTL settings and authoritative DNS configuration. A lower TTL can make a planned change easier to reverse, but it does not force every recursive resolver to discard an existing answer immediately. Plan for overlap between old and new paths instead of assuming a synchronized global switch.
2. Origin reachability and trust
Verify that the new CDN can connect to the origin over the intended port and protocol. Test the origin certificate name, certificate chain, supported TLS versions, SNI behavior, firewall allowlists, health checks, and host header handling. If the origin currently trusts requests only from the old CDN, update the rules carefully and retain a controlled administrative path for emergency access.
Do not rely on an origin test that uses only the server IP. Test with the production hostname and the same host header expected from the CDN. Check both the homepage and representative dynamic routes, authenticated areas, form submissions, API requests, media files, and error responses.
3. Cache keys and bypass rules
Compare how each CDN builds a cache key. Review hostname, path, query strings, cookies, authorization headers, device signals, language, and compression variants. A cache key that is too broad can serve one visitor's content to another; one that is too narrow can produce poor hit rates without improving correctness.
Mark private or state-changing paths as bypass candidates. Common examples include account pages, carts, checkout, payment flows, personalized dashboards, previews, login endpoints, and authenticated API responses. For APIs, review the rules alongside the request method, authentication model, ETags, and invalidation process; the API caching guide provides a useful framework.
4. Headers, TTLs, and purging
Record response headers from the existing CDN and origin, including Cache-Control, Age, ETag, Last-Modified, Vary, and any provider-specific cache-status header. Decide whether the new CDN should honor origin headers, apply edge TTL overrides, or use separate policies by path. Review the difference between browser caching and edge caching; a purge at the CDN does not necessarily remove a response already stored in a visitor's browser.
Test the purge workflow before cutover. Confirm whether purges can target a URL, prefix, hostname, tag, or entire zone, and document who can run them. Keep the CDN edge caching setup guide and the cache-control and invalidation guide available during review.
5. TLS, redirects, and application behavior
Confirm that every production hostname, including alternate domains and wildcard or regional names where applicable, is covered by the new CDN's certificate configuration. Test HTTP-to-HTTPS redirects, canonical host redirects, trailing-slash behavior, port handling, and redirect chains. Check that the origin does not redirect the CDN to an internal hostname or an unintended scheme.
Compare security headers, content encoding, range requests for large files, image transformations, upload limits, WebSocket or streaming behavior, and custom error pages. These features are easy to overlook when the primary test is a cached HTML page.
Migration checklist
| Phase | Completion check |
|---|---|
| Document | Hostnames, DNS records, origin details, rules, certificates, and baselines are recorded. |
| Build | The new CDN has matching cache, TLS, redirect, security, and bypass policies. |
| Test | Preview traffic reaches the origin correctly and returns expected headers and content. |
| Prepare | Monitoring, purge access, DNS rollback values, and an owner for the change are ready. |
| Cut over | DNS or routing changes are made during an observed maintenance window, even if downtime is not expected. |
| Verify | Real-user traffic, origin load, cache status, errors, TLS, and key journeys remain healthy. |
Cadence and checkpoints
Use a short, explicit schedule rather than treating migration as complete when DNS appears to have changed.
- Before the change: Capture baseline measurements for response time, origin load, cache hit behavior, error rates, redirects, and important Core Web Vitals. A repeatable TTFB and Core Web Vitals checklist can help make the comparison meaningful.
- During staged testing: Request cacheable and uncacheable URLs more than once. Confirm that the first response and subsequent response behave as intended, and inspect headers from multiple locations when possible.
- Immediately after cutover: Test DNS resolution, certificate validity, homepage rendering, login, search, forms, checkout, APIs, media, redirects, and representative uncached URLs. Watch origin CPU, memory, connections, bandwidth, and application errors.
- After the initial traffic cycle: Compare cache hit behavior, latency, status codes, bot or crawler traffic, and traffic by hostname. Some defects appear only when cache objects expire or when a less common query string is requested.
- Monthly or quarterly: Review cache rules, TTLs, certificate renewal status, DNS records, purge procedures, origin firewall rules, and monitoring coverage. Re-test important journeys after major application, hosting, or CDN changes.
How to interpret changes
A lower cache hit ratio is not automatically a failure. It may reflect more personalized traffic, a deliberate bypass rule, changed query-string handling, or a shorter TTL. Investigate it alongside origin request volume, response time, and correctness. If the origin is receiving substantially more requests and the affected URLs should be public and cacheable, inspect the cache key and response headers first.
A sudden increase in errors can come from several layers. Compare edge status codes with origin status codes, then check TLS handshakes, firewall logs, health checks, and application logs. A high edge error rate with normal origin logs may indicate a certificate, routing, or provider rule problem. A high origin error rate may indicate that the new CDN is forwarding requests differently or that the origin cannot handle the connection pattern.
Slower TTFB does not always mean the CDN is farther away. It can result from cache misses, a different connection mode to the origin, disabled compression, an extra redirect, or a cache key that fragments traffic. Test the same URL as a cold request and a warm request, and compare headers before changing several settings at once.
Incorrect content is more urgent than a modest performance regression. If a response contains the wrong language, account state, price, or user-specific data, bypass it immediately and investigate cookies, authorization headers, query strings, and Vary behavior. Ecommerce sites should be especially cautious with cart, checkout, inventory, and promotional responses. The WooCommerce caching guide explains why these exclusions deserve explicit testing.
When to revisit
Revisit this checklist before every CDN migration, domain change, hosting move, major cache-policy revision, certificate change, or origin firewall update. Even when the CDN remains the same, an application release can alter headers, cookies, URL patterns, or response personalization enough to invalidate an earlier assumption.
Set a recurring monthly or quarterly review for the variables that tend to drift: DNS records and TTLs, certificate coverage, cache hit and bypass patterns, purge success, origin load, error rates, redirect behavior, and key user journeys. Keep a dated baseline so a future review can distinguish normal seasonal traffic from a configuration regression.
For the next migration, turn the review into an operational runbook. Assign an owner, write down the exact DNS rollback value, save test URLs, define stop conditions, and specify how long the old CDN will remain available. After the cutover, record what changed and what was observed. This makes the next website caching migration safer, faster to validate, and less dependent on memory.
Finally, audit the broader caching design periodically. Understanding page cache versus object cache versus CDN edge cache helps prevent a common migration mistake: treating the CDN as an isolated layer when the origin and application caches are part of the same delivery path.