A CDN can be enabled while visitors still receive slow responses from the origin. This website cache audit checklist shows how to verify cache behavior with response headers, browser developer tools, CDN logs, curl, and origin timing data, then turn the findings into a repeatable monthly or quarterly performance review.
Overview
A cache audit answers three separate questions: is the request reaching an edge location, is the edge serving a stored response, and is the origin taking too long when a miss occurs? Treating these as one question often leads to ineffective fixes. A low cache hit ratio may be caused by short freshness settings, cookies, query strings, bypass rules, personalized HTML, deployment behavior, or simply a test sample that contains mostly uncachable URLs.
Start with a representative URL set rather than testing one homepage repeatedly. Include the homepage, a typical article or product page, CSS and JavaScript files, images, a search or filtered URL, and any public API response that is intended to be cached. Exclude account pages, checkout flows, cart pages, admin routes, and other private responses unless the purpose of the audit is to confirm that they are correctly bypassing the cache.
Record each test before changing configuration. A baseline makes it possible to distinguish a genuine improvement from a cache that is temporarily warm because of your own testing. For broader context, compare the findings with the metrics and response-time guidance in the CDN analytics guide.
What to track
1. Response headers
Inspect the complete response header set. Useful fields may include Cache-Control, Age, ETag, Last-Modified, and a provider-specific cache status such as CF-Cache-Status, X-Cache, CDN-Cache-Control, or a vendor diagnostic header. Names and meanings vary, so confirm the interpretation in your provider documentation rather than assuming that every HIT or MISS has the same scope.
Look for signals that explain a bypass. A response containing Set-Cookie, a private directive, a zero or very short max-age, or a no-store directive may be intentionally excluded from shared caching. A response can also be cacheable at the browser but not at the CDN, or cacheable at the CDN while being revalidated frequently. Document both the intended policy and the observed policy.
2. Browser developer tools
In Chromium-based browsers, open Developer Tools, select the Network panel, enable the option to preserve the log if navigation matters, and reload the page. Firefox and other browsers provide similar request panels, although labels and placement differ by version. Select the document request and inspect Headers, Timing, and, where available, the response size and transfer details.
Use the Timing panel to separate queueing, DNS, connection setup, TLS negotiation, request waiting, and download time. A long “Waiting for server response” period points toward origin, edge processing, or an upstream application delay; it does not by itself prove that the request missed the cache. Also check whether the browser is reusing a local cache. Test with a controlled reload and record whether the request was served from memory or disk cache.
3. Repeatable curl checks
Command-line checks are useful because they expose headers without relying on browser interpretation. Run a header request where the origin and CDN support it:
curl -sS -D - -o /dev/null https://www.example.com/page/
To capture timing values, use a format string such as:
curl -sS -o /dev/null -w "status=%{http_code} ttfb=%{time_starttransfer} total=%{time_total} size=%{size_download}\n" https://www.example.com/page/
Repeat the same URL several times, with a pause between requests when appropriate, and compare results from more than one network or region. Add -I only when you know the provider and origin handle HEAD like GET; otherwise a header capture with GET is a safer representation of a visitor request. Never use a query-string test parameter unless you intend to test a different cache key.
4. CDN and origin data
Compare edge logs with origin access logs for the same period. Track requests, bytes served, cache status, cache key or URL pattern, region, response status, and whether the request was forwarded. At the origin, measure time spent waiting for the application, database, upstream API, and network response where your stack provides those fields.
For each URL sample, record:
- URL pattern and content type
- Test date, time zone, and deployment state
- Test region and device or request profile
- Edge cache status and relevant headers
- TTFB and total response time
- Cache-Control directives, cookies, and query strings
- Origin response time when the request is forwarded
- Suspected cause, corrective action, and follow-up result
Keep cache status separate from cache hit ratio. A status header describes an individual response, while a hit ratio is an aggregate calculated over a defined request population and time window. Excluding dynamic or intentionally bypassed traffic can make the aggregate more useful, but the exclusion rules must be documented.
Cadence and checkpoints
Run a lightweight audit monthly for sites with regular publishing or deployment activity, and at least quarterly for stable sites. Perform a full audit before a campaign, product launch, traffic increase, CDN migration, domain or DNS change, major WordPress update, or significant cache-rule change. Repeat the audit after a deployment has had enough time for normal traffic to populate the edge; an immediate post-purge result may reflect cold-cache behavior rather than a permanent problem.
Use the same URL list, regions, device profiles, and time window whenever possible. If those variables change, label the comparison clearly. A useful audit sheet has one row per URL and columns for baseline status, new status, baseline TTFB, new TTFB, origin request rate, and the next action.
| Observed pattern | Common causes to investigate | Next check |
|---|---|---|
| Most public pages show MISS | HTML is not cacheable, a bypass rule matches, cookies vary the request, or the cache was recently purged | Inspect Cache-Control, cookies, cache rules, and cache age across repeated requests |
| Static assets show MISS repeatedly | Asset hostname is not routed through the CDN, query strings create separate keys, or assets are marked private | Check DNS, the asset URL, cache key settings, and immutable versioning |
| Hit ratio is acceptable but TTFB remains high | The sample contains misses, edge processing is slow, the nearest location is distant, or the origin is slow on uncached paths | Segment by status, region, URL, and origin time instead of using one average |
| Cache status differs by region | Regional cold caches, inconsistent configuration, or different routing paths | Repeat tests from fixed regions and compare provider logs |
| Performance drops after every deployment | Broad purges, changed asset URLs, reduced TTLs, or cache rules being overwritten | Review deployment invalidation and cache-busting behavior |
| Private pages appear cacheable | Missing bypass conditions, incomplete cookie handling, or an overly broad page rule | Stop the test, verify authorization boundaries, and correct the rule before optimizing hit rate |
Do not optimize for the highest possible hit ratio at the expense of correctness. Public HTML, static assets, and carefully designed API responses can often use edge caching, while personalized pages and transactional operations generally require stricter handling. The Cloudflare caching rules guide and WordPress caching guide provide additional context for separating these traffic types.
How to interpret changes
First classify the change as a cache-behavior change or an origin-performance change. If cache misses increase and origin requests rise with them, investigate cacheability and cache keys. If hit ratio is stable but TTFB for misses worsens, investigate application execution, database load, upstream services, connection reuse, and origin capacity. If both improve only in one region, inspect routing and regional cache state.
Check distributions rather than averages alone. A healthy mean can hide a slow tail affecting a particular region, device type, URL family, or response status. Break the report into anonymous versus authenticated requests, HTML versus assets, mobile versus desktop profiles, and cache hits versus misses. Compare like with like: a large uncached document should not be judged against a tiny cached stylesheet.
When making a correction, change one related group of settings at a time. Examples include extending the freshness period for versioned assets, removing an accidental cookie variation from public content, narrowing a bypass rule, or fixing an asset hostname that points directly to the origin. Purge only the affected objects when possible, then run the same tests and record the result. For cache-busting details, see the guide to versioning CSS, JavaScript, and images.
A cache hit is not automatically a fast response. Review edge processing time, transfer size, compression, connection setup, and geographic distance as well. Conversely, a cache miss is not automatically a configuration failure: the first request after publication, a deliberate purge, or an uncachable private response may be expected.
When to revisit
Schedule the next audit monthly or quarterly, depending on how often the site changes. Revisit immediately after a CDN configuration edit, origin migration, DNS change, WordPress caching plugin update, deployment pipeline change, cache purge, or unexpected TTFB increase. Also repeat the review when CDN products change their dashboard labels or diagnostic headers; vendor terminology and browser interfaces can change even when the underlying HTTP behavior does not.
Keep the audit template with the project’s operational documentation. At each review, archive the URL sample, test regions, timestamp, response headers, cache-status interpretation, hit ratio definition, and corrective actions. Mark each issue as fixed, monitoring, expected, or unresolved. This prevents teams from reopening the same investigation without knowing what was already tested.
Finish every audit with three actions: identify the largest avoidable source of origin traffic, verify that public and private content have the correct cache boundaries, and schedule a follow-up measurement. If the origin is a single point of failure, pair the cache review with a CDN failover and origin-outage runbook. If the main issue is slow uncached response time, use the TTFB improvement guide to continue from diagnosis to remediation.