---
title: WordPress Changes Not Showing? Find Which Cache Is Answering
description: "WordPress changes not showing? Check the cache header while logged out, purge the page cache or CDN, clear your browser, and edit the CSS file that loads."
url: "https://skybootstrap.com/wordpress-changes-not-showing/"
canonical_url: "https://skybootstrap.com/wordpress-changes-not-showing/"
date: "2026-11-22T06:22:00+06:00"
modified: "2026-11-16T16:58:39+06:00"
author: Skybootstrap Team
type: article
site: SkyBootstrap
language: en-US
---

# WordPress Changes Not Showing? Find Which Cache Is Answering

If you see WordPress changes not showing on the live site, in our tests the cause was a stored copy of the page answering instead of WordPress, or an edited file the site doesn’t load. Open the page logged out in a private window and check its response headers to see which cache served it. Then purge that cache, or edit the file the page actually uses.

Most cases below were reproduced on a test site (WordPress 7.1.3 behind an nginx page cache; the browser case on Apache in Chromium), not a live site. We didn’t test caching plugins, host caches or CDNs. In one test, we saw our edit while a visitor kept getting the old page.

## Why WordPress changes are not showing

WordPress changes are not showing whenever an old copy answers before WordPress does. A page cache is a store of finished pages that the server hands out without running WordPress again. A browser cache is the same idea on your own computer.

Either can serve an old copy after you save, and so can a CDN, a network of servers that keeps copies of your site around the world. Here’s where the old version came from in our lab:

| Where the old copy lived | What we saw | Fix that worked |
| --- | --- | --- |
| Server page cache | Old title with `X-Cache: HIT` until we purged it | Purge the page cache |
| Page cache that skips logged-in users | Admin saw the new title; visitors saw the old one | Purge, then check logged out |
| Your browser | In our redirect test, a browser that had followed an old redirect kept following it after the fix | A fresh browser profile |
| The theme’s CSS file | An edit to `style.css` never reached the page | Edit the file the theme loads |

The WordPress Advanced Administration Handbook’s common errors page names one cause for changes that don’t show: your browser may be loading stored data.

## Check whether a cache is answering

To check whether a cache is answering, look at the page the way a visitor does: logged out, in a private window. Then read the response headers, the lines a server sends before the page itself; checked in your normal logged-in browser, a cache that skips admins would look like no cache at all. The handbook also advises keeping `wp-login.php` and logged-in sessions out of page caching; if a new cache has broken your login, our locked-out guide walks through each way back in. On our test site, a cache that skipped logged-in users showed us, the admin, the edited title:

![Logged-in admin bar above the WordPress post title Hello world, updated title, the view an admin gets while changes are not showing for visitors](https://skybootstrap.com/wp-content/uploads/2026/11/changes-not-showing-logged-in-admin.webp "Test site, 2 Nov 2026: WordPress 7.1.3, nginx page cache. Logged in: the cache was bypassed.")

At the same moment, a visitor got the old one from the cache:

![The same WordPress post with its old title, served from the page cache to a logged-out visitor](https://skybootstrap.com/wp-content/uploads/2026/11/changes-not-showing-visitor-cached.webp "Test site, 2 Nov 2026: WordPress 7.1.3, nginx page cache. Logged out: X-Cache said HIT.")

curl is a command-line program you run on your own computer, and with `-sIL` it shows a page’s headers, following any redirects first. On macOS or Linux:

```
curl -sIL https://example.com/your-page/
```

X-Cache is the header our server added to name the cache result. It said `HIT` when the stored copy answered, `MISS` when WordPress built the page fresh, and `BYPASS` for our logged-in visits.

Caching plugins, hosts and CDNs use their own header names, so look for anything with “cache” in it; we only tested our own. If no header mentions a cache, that doesn’t prove there isn’t one, so check your caching plugin or ask your host. Browser developer tools (in the private window, Network tab, after a reload) and Windows’ `curl.exe` show the same headers, though we didn’t test either.

## Clear the page cache

Purge the cache that answered, then look again while logged out. On our test site, purging the page cache brought the new title straight away, with `X-Cache: MISS` on the next request.

- **A caching plugin:** use its “clear cache” or “purge” button in wp-admin. We didn’t test named plugins, so look in the plugin’s toolbar menu or settings.
- **Your host’s cache:** look for a cache or performance tool in the hosting panel and clear it there (not tested).
- **Your own server:** empty the folder named in your nginx configuration’s `fastcgi_cache_path` line. Ours was `/var/cache/nginx/w1`; check the path twice before deleting its contents, and leave the folder itself in place.

A cache stores mistakes as faithfully as pages. A blank page our test code produced stayed in the page cache after we fixed the code, and only came back to normal after a purge. If a blank page is what’s stuck, our [white screen guide](https://skybootstrap.com/wordpress-white-screen-of-death/) finds the code behind it; if it’s a redirect your browser keeps repeating, the [redirect loop guide](https://skybootstrap.com/wordpress-too-many-redirects/) shows how to trace it.

## Clear your browser cache

Clear your browser cache when the page is new in a fresh private window but old in your usual browser, because the browser is holding a stored copy. The [handbook’s common errors page](https://developer.wordpress.org/advanced-administration/wordpress/common-errors/) suggests emptying the browser cache or closing the tab and opening the link again; we didn’t test those steps. In our redirect test in Chromium, a profile that had followed an old redirect kept following it after the fix, while a fresh profile loaded the page.

## When a CSS or code change doesn’t show

When a CSS or code change doesn’t show, check that you edited the file the page actually loads: view the page source and search for the theme’s name. On our test site there was no link to `style.css`, only an inline `<style id='twentytwentyfive-style-inline-css'>` block built from another file. Some themes, ours included, ship a minified copy of their stylesheet, `style.min.css`, which is the same rules with the spaces removed. Our Twenty Twenty-Five 1.5 test site loaded that file, so a rule we added to `style.css` never reached the page, while the same rule in `style.min.css` did.

SCRIPT_DEBUG is a wp-config.php setting for developers. The [handbook’s debugging page](https://developer.wordpress.org/advanced-administration/debug/debug-wordpress/) says it makes WordPress use the “dev” versions of core CSS and JavaScript files rather than the minified ones. When we set it to `true`, our theme loaded the `style.css` rule too, but leave it off on a live site.

For lasting changes, the handbook’s CSS page points to custom CSS (in the Site Editor’s Styles since WordPress 6.2, or the Customizer’s Additional CSS), and its file-editing page to a child theme, because a theme update overwrites direct edits. If you must edit a theme file, copy it first through your file manager or SFTP so you can put it back.

PHP files have a short delay of their own. OPcache is PHP’s store of compiled code, and on our server it rechecks changed files every 2 seconds, so on a server set like ours a few seconds is enough. Your host may use a longer interval, which we didn’t test.

## Purge a CDN or host cache

If the header names a CDN or your host, purge the copy there; clearing WordPress’s cache doesn’t reach it. The CDN’s dashboard or your hosting panel will have the purge option. We didn’t test a CDN, so check its documentation for which header shows a cached response.

There’s one more layer: the object cache. The handbook describes it as a separate system that stores database results, using an `object-cache.php` file in `wp-content` (Redis or Memcached, for example). If your site has that file, the plugin behind it may offer a flush option; we didn’t test whether an object cache delays changes. When the page itself shows an error rather than old content, the debug log steps in our [WordPress errors guide](https://skybootstrap.com/wordpress-errors/) are the place to begin.

## Frequently Asked Questions

### Why can I see my changes but visitors can’t?

A page cache can be set to skip logged-in users, as ours was, so you see a freshly built page while visitors get the stored one. That’s exactly what happened on our test site until we purged the cache. Always check your changes logged out or in a private window.

### How long until WordPress changes show up?

As long as the stored copy is allowed to live. Our test cache kept pages for up to 10 minutes after storing them (`fastcgi_cache_valid 200 10m`); we purged rather than waited. Your plugin, host or CDN sets its own time. Purging makes the change appear at once.

### My update finished, so why does the site look the same?

The same caches apply after a plugin or theme update. Check the version in wp-admin first; if it’s new, purge the page cache and check logged out. If the version is still old, our update failed guide helps you finish the update.

## How we tested

We made a change and watched where it didn’t show, on 2 November 2026. The test site ran WordPress 7.1.3 with PHP-FPM 8.3.6 behind nginx 1.24.0, with a FastCGI page cache that added an X-Cache header.

First, we edited a post title while the cache held the page, with a cache that served everyone and then one that skipped logged-in users. We checked both views in Chromium and with curl. Next we added a CSS rule to Twenty Twenty-Five 1.5’s style.css and then to style.min.css, and checked the style.css rule again with SCRIPT_DEBUG on.

The cached blank page comes from our white screen test, and the redirect a browser kept from our redirect test on Apache 2.4.58. We didn’t test caching plugins, host caches or CDNs. The cache settings and the post were restored afterwards.