Why Is My Website Cache Not Updating? A Layer-by-Layer Troubleshooting Guide
Cache TroubleshootingCDNBrowser CacheWordPressHTTP HeadersDebugging

Why Is My Website Cache Not Updating? A Layer-by-Layer Troubleshooting Guide

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

A layer-by-layer checklist for diagnosing stale website content across browsers, WordPress, reverse proxies, origins, and CDNs.

If your website still shows an old version after you cleared the cache, the problem is usually not one cache but a chain of caching layers. This guide gives you a reusable, layer-by-layer checklist for identifying stale content in browsers, service workers, WordPress, reverse proxies, origin servers, and CDNs—without purging everything blindly.

Overview

A modern website may be cached in several places before a visitor sees it. A browser can reuse stored files, a service worker can intercept requests, a WordPress cache plugin can serve a saved HTML page, and a reverse proxy or CDN can return an object from an edge location instead of contacting the origin server. DNS, cookies, query strings, cache keys, and response headers can also change which version a visitor receives.

That is why “I cleared the cache” is not a complete diagnosis. You need to identify which layer served the response, whether that layer has been purged, and whether the request you tested matches the request made by affected visitors.

Use this order when investigating:

  1. Confirm the change exists at the origin.
  2. Test the URL without browser extensions, stored files, or service-worker interference.
  3. Inspect response headers and cache status.
  4. Check WordPress, reverse-proxy, and CDN behavior in sequence.
  5. Compare requests with different cookies, query strings, devices, and locations.
  6. Only then change TTL settings or purge broader cache groups.

For background on coordinating invalidation across multiple layers, see Cache Invalidation Strategy: How to Purge Website Caches Without Serving Stale Content. If the issue is actually a misunderstanding between saved pages and database results, compare page cache vs. object cache.

Checklist by scenario

After publishing an edited page

  • Open the page directly on the origin or a temporary origin hostname, if your deployment supports one.
  • Check that the published content is present in the database or source files and that the deployment completed successfully.
  • Use a private browser window and disable extensions that modify pages or requests.
  • Perform a hard reload, but do not treat it as proof that every cache layer has been cleared.
  • Purge the specific WordPress page or page-cache entry, then purge the relevant CDN URL if necessary.
  • Request the page with curl and record the headers before and after purging.

After changing CSS, JavaScript, images, or other assets

Asset files often have longer TTL settings than HTML. If an edited stylesheet keeps its old version, check whether the filename stayed the same. The durable solution is usually cache busting: publish a new filename or append a version value that is part of the cache key. For example:

<link rel="stylesheet" href="/assets/site.css?v=20261105">

Do not assume that changing a query string always works. Some cache configurations ignore query strings, while others create a separate cached object for every value. Confirm the behavior with response headers and a request using the exact asset URL.

When only some visitors see old content

  • Compare the affected and unaffected URLs, including protocol, hostname, path, and query string.
  • Check cookies and authorization headers. Personalized or logged-in requests may bypass the cache or use a different cache key.
  • Test from more than one network or location to identify an edge-specific issue.
  • Compare the CDN status header, age value, cache-control directives, and any provider-specific diagnostic headers.
  • Check whether DNS recently changed and whether different resolvers still point to different origins.

Inconsistent results can be caused by normal edge propagation, multiple origins, a stale reverse proxy, or a DNS migration rather than a browser problem. Use the DNS migration checklist when the hostname or origin has recently changed.

When WordPress shows an old page

  • Clear the page cache in the active cache plugin or hosting control panel.
  • Check whether the plugin has separate mobile, logged-in, language, or device variants.
  • Confirm that the page is not being served by a host-level cache, Nginx FastCGI cache, Varnish cache, or CDN after the plugin purge.
  • Exclude cart, checkout, account, preview, and other user-specific routes from full-page caching where appropriate.
  • Verify that an object cache such as Redis is not being confused with page cache. Object-cache invalidation may be required after changing settings or content queried from the database.

For WooCommerce or other dynamic applications, test both an anonymous product request and a logged-in or cart request. Caching rules that work for public pages can produce incorrect behavior when cookies or session state are involved.

When a deployment or server migration is involved

  • Confirm the new files and configuration are present on every origin behind the load balancer.
  • Check whether the CDN points to the new hostname, IP address, or origin pool.
  • Review cache keys for hostname, scheme, path, query string, cookies, and request headers.
  • Inspect stale-on-error behavior. A proxy may intentionally serve an old successful response when the origin returns an error.
  • Compare the old and new server response headers, including ETag, Last-Modified, Age, and Cache-Control.

What to double-check

Use headers as evidence

Open browser developer tools, select the Network panel, reload the page, and inspect the document request. Useful headers include:

Header or signalWhat it can indicateWhat to check
Cache-ControlBrowser and shared-cache instructionsReview max-age, s-maxage, no-cache, and no-store.
AgeApproximate time an intermediary has held an objectA growing value can indicate an intermediary response rather than a fresh origin response.
ETag and Last-ModifiedValidation information for stored responsesCompare values between the expected and delivered versions.
Via, X-Cache, or provider status headersPossible proxy or CDN cache statusInterpret labels according to the active provider and configuration.
Set-Cookie and VarySignals that responses may differ by visitor or request headersCheck whether cookies or headers create separate cache variants or bypass caching.

Header names and status labels differ between platforms, so do not treat a value such as “HIT,” “MISS,” or “BYPASS” as universal. Record the actual request URL, timestamp, status, and response headers for comparison.

Run command-line checks

Command-line requests help separate browser behavior from server behavior:

curl -I https://example.com/page
curl -sS -D - -o /dev/null https://example.com/page
curl -H 'Cache-Control: no-cache' -sS -D - -o /dev/null https://example.com/page

The third command is a diagnostic request, not a guarantee that every intermediary will ignore its stored object. Compare it with a normal request and, where safe, test the origin directly. Do not send cache-bypass headers to production repeatedly at high volume.

Check service workers and browser storage

A service worker can return a cached response before the ordinary HTTP cache is consulted. In browser developer tools, inspect the Application or Storage area, identify registered service workers, and check their cache names and scope. Test with the service worker temporarily bypassed or unregistered only in a controlled debugging session. If that resolves the problem, review the worker's update and cache-versioning logic rather than permanently disabling it for visitors.

Verify cache keys and variants

A purge can appear ineffective when it removes one object but the visitor requests another. Common differences include:

  • http versus https
  • www versus the apex domain
  • trailing slash or URL normalization
  • uppercase and lowercase paths
  • query-string parameters
  • language, device, or compression variants
  • cookies and authorization headers

Document these rules in a cache configuration matrix. The cache configuration matrix for Nginx, Varnish, Cloudflare, and CDNs can serve as a starting point.

Common mistakes

  • Purging only the browser: A hard reload cannot remove a stale CDN, reverse-proxy, or WordPress page-cache object.
  • Purging only the CDN: The CDN may immediately fetch old HTML from a server-side cache.
  • Changing TTL before finding the cause: A longer TTL can make the symptom last longer, while a very short TTL can increase origin load.
  • Testing while logged in: Logged-in responses often bypass public caches and can hide the behavior affecting anonymous visitors.
  • Ignoring stale error responses: A proxy may retain an error or serve stale content during origin failures. Check status codes and origin health, not just page text.
  • Purging everything as a first response: Broad invalidation can increase origin traffic and obscure which layer was responsible.
  • Assuming DNS is cache invalidation: DNS changes influence where requests go; they do not necessarily remove cached HTTP objects.
  • Skipping a before-and-after record: Without URLs, headers, timestamps, and test locations, it is difficult to prove which change fixed the issue.

If cache purges are followed by high origin load or slow responses, review cache capacity and resource limits using this guide to PHP workers, RAM, and storage.

When to revisit

Revisit this checklist whenever visitors report inconsistent content, after publishing a major edit, or after changing cache rules, a cache plugin, hosting provider, CDN, DNS records, deployment process, or service worker. It is also worth reviewing before seasonal traffic increases and whenever workflows or diagnostic tools change.

Keep a short runbook with the following fields:

  1. Canonical URL and known variants.
  2. Every caching layer and its purge method.
  3. Expected TTL and bypass rules.
  4. Relevant response headers and status labels.
  5. Commands for normal, validated, and origin requests.
  6. Safe exclusions for logged-in, transactional, and personalized routes.
  7. The person or system responsible for each layer.

After making a fix, test from a clean browser session, an authenticated session where relevant, at least one separate network, and the command line. Confirm both fresh content and normal cache behavior. A successful purge is not the final goal: the durable result is a predictable invalidation workflow that keeps pages fresh without sacrificing the performance benefits of website caching.

For ongoing verification, pair this process with cache hit-ratio monitoring and a release test for Core Web Vitals and caching regressions.

Related Topics

#Cache Troubleshooting#CDN#Browser Cache#WordPress#HTTP Headers#Debugging
C

Caching.website Editorial Team

Technical 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.