What’s actually slowing this PC down?
Pick the symptom - the matching free tool is one click away.
To enable caching safely, first check whether your host already provides full-page caching or Varnish. If it does not, install one maintained page-cache plugin, enable its page cache, generate pages while logged out, and purge the cache whenever published content or site settings change. Keep browser, page, reverse-proxy, and object caching separate, and never let two independent page-cache systems manage the same HTML without a clear purge plan.
Antihost offers managed WordPress hosting with free migration, one-click staging and a 14-day free trial.
Check your hosting before installing anything
Many WordPress hosts place a full-page cache, reverse proxy, CDN, or object cache in front of WordPress. Ask support or inspect the hosting dashboard for terms such as page cache, Varnish, reverse proxy, edge cache, or object cache. WordPress documentation describes Varnish as a system-level cache that can work alongside a WordPress caching plugin.
As an Amazon Associate I earn from qualifying purchases.
If the host already serves cached HTML, learn how it purges pages and whether it automatically clears the cache after a post, menu, theme, or plugin change. Installing another page-cache plugin may create conflicting rewrite rules, response headers, or purge commands. In that situation, either use the host’s documented integration or disable one page-cache authority before enabling another.
Questions to ask the host
- Is full-page HTML caching active for anonymous visitors?
- Does the host use Varnish or another reverse proxy?
- Is a CDN caching HTML, or only images, stylesheets, and scripts?
- How are cached pages purged after publishing?
- Is persistent object caching available, and which object-cache service does it use?
Understand the caching layers
Caching is not one switch. Each layer stores a different kind of response and has its own invalidation rules.
#1 Best Overall
| Layer | Where it runs | What it stores | What it changes |
|---|---|---|---|
| Page cache | WordPress plugin or server | Generated HTML for posts and pages | Serves a ready-made response instead of rebuilding the page through the full WordPress PHP stack |
| Reverse-proxy cache | Server or edge proxy, such as Varnish | HTTP responses, commonly public HTML | Can answer a request before PHP runs |
| Browser cache | Visitor’s device | Images, CSS, JavaScript, and other reusable files | Reuses files locally until their freshness lifetime ends or they are revalidated |
| Object cache | Server-side object store | Reusable database objects and query results | Reduces repeated database work while WordPress still generates the response |
A page cache and a browser cache therefore solve different problems. A page cache reduces server-side page generation; browser caching reduces downloads for returning visitors. A site can use both, but each must be tested and purged independently.
Choose one page-cache approach
WordPress’s Advanced Administration Handbook identifies W3 Total Cache, WP Super Cache, and Cache Enabler as plugins that turn posts and pages into static files. Choose one that is maintained and compatible with your host rather than activating several independent page-cache plugins.
Do these 3 things before closing this tab:
1Scan for outdated or missing drivers - takes under a minute2Clear out junk files and repair common Windows errors3Fix the driver behind crashes, sound loss and screen glitches| Approach | Runs in | Primary cached content | Best fit |
|---|---|---|---|
| Host-provided full-page cache or Varnish | Hosting server or reverse proxy | Public HTML responses | A site whose host supplies documented caching and purge controls |
| WP Super Cache | WordPress plugin | Static HTML files for posts and pages | A site needing a direct plugin-based page-cache setup; its documented path is Settings → WP Super Cache → enable caching |
| W3 Total Cache | WordPress plugin | Static files for posts and pages, with additional cache layers available in its settings | A site whose administrator wants a configurable caching plugin and understands each enabled layer |
| Cache Enabler | WordPress plugin | Static HTML files for posts and pages | A site choosing a separate maintained page-cache plugin instead of the alternatives |
| Browser caching | Visitor’s browser | Images, CSS, and JavaScript | Every site that wants repeat visits to reuse unchanged static assets |
| Object caching | Server-side object store | Database objects and query results | Sites where repeated database work remains expensive after page caching |
Enable page caching with WP Super Cache
The following workflow uses WP Super Cache because its official documentation gives an explicit settings path and cache-file checks. The same principles apply if your host or another plugin is your chosen page-cache authority.
- Install the plugin. In the WordPress dashboard, open Plugins → Add New, search for WP Super Cache, install it from the WordPress plugin directory, and activate it.
- Open the cache settings. Go to Settings → WP Super Cache.
- Enable caching. On the plugin’s Easy settings screen, select the option to enable caching and save the setting. This allows the plugin to write static responses in its cache directory.
- Generate representative pages. Open your home page, a post, a page, an archive, and any other public templates in a private or logged-out browser window. The first request can build the cached file; later anonymous requests should be eligible to receive it.
- Check generated files. Use the plugin’s cache and generated-file controls to confirm that files are being created. The exact directory is managed by the plugin; do not edit or delete individual files unless its documentation directs you to do so.
- Purge after changes. Use the plugin’s clear-cache control after publishing, editing menus, changing a theme or stylesheet, changing plugin settings, or altering a widget. Regenerate important pages by visiting them again while logged out.
- Test before declaring success. Compare an initial request and a repeat request in the browser’s Network panel, then repeat the check with a logged-in account to confirm that private responses are not being shared.
Do not enable a second independent page-cache plugin merely because its dashboard offers a different optimization. If the host already owns page caching, follow its purge and exclusion rules or disable that layer before making the plugin the authority.
Configure browser caching for static assets
Browser caching applies to files such as images, CSS, and JavaScript, not to the generated HTML page itself. The server communicates freshness with HTTP headers:
Cache-Control, especially a positivemax-age, tells the browser how long it may reuse a response.Expiressupplies an expiration time for clients that use that header.- An entity tag, commonly called an
ETag, lets the browser validate whether a stored file changed.
When a stored asset is still fresh, the browser can use it without downloading it again. When it is stale, the browser can revalidate; an unchanged file can produce a 304 Not Modified response instead of sending the full asset again. Set these headers through the host, CDN, or caching plugin according to the layer that owns static assets. Avoid creating contradictory rules in several places.
Quick wins for a faster PC:
Fix the driver behind crashes, sound loss and screen glitchesFind Drivers →Repair Windows errors before they cause bigger problemsFix Now →Scan for outdated or missing drivers - takes under a minuteDriver Scan →Exclude private and dynamic responses
Shared page caches are designed for public responses. They must not serve one visitor’s personalized HTML to another visitor.
- Exclude logged-in users and account dashboards.
- Exclude shopping carts, checkout, order history, and other transaction pages.
- Exclude preview URLs and editorial tools.
- Exclude pages that vary by membership, location, subscription, or another user-specific condition.
- Exclude commenter-specific responses and any endpoint that sets or reads a private session cookie.
WordPress provides nocache_headers() for responses that must not be cached. A developer can send those headers from code, while the page-cache and reverse-proxy configuration must also contain matching exclusion rules. One documented Batcache implementation skips cookies beginning with wp, wordpress, or comment_author; that is an example of one implementation, not a universal rule for every host or plugin.
When a page combines public HTML with personalized data, cache the public shell only and load the private portion separately through an authenticated or client-side request. Do not rely on a public full-page cache to understand every plugin’s cookies automatically.
How to verify that caching is working
Test as an anonymous visitor
- Open a private window or log out of WordPress.
- Open the page once to allow an uncached request to generate or populate the response.
- Reload the same URL and inspect the request in the browser’s Network panel.
- Record the response headers and repeat the test after clearing the relevant cache.
WordPress.com documentation recommends using a GET request when checking cached responses. A browser’s Network panel shows whether the response came from memory, disk, a CDN, a reverse proxy, or the origin server, depending on the headers exposed by your stack.
Inspect response headers
WordPress Site Health recognizes cache indicators including a Cache-Control header with a positive max-age and X-Varnish patterns. These headers are evidence that a cache layer is communicating with the request, although the exact header names vary by host and proxy. A header alone does not prove that every URL is cached; test several public templates and verify that private URLs are excluded.
Repeat the test while logged in
Logged-in requests may intentionally bypass page caching. That is expected when the site must show an administrator’s toolbar, draft content, or account data. A successful setup can therefore show a cache indicator for a logged-out request and no shared-cache response for the same URL while logged in.
Rank #4
Why visitors still see an old version
Stale content usually means that one layer was purged while another still holds the old response. Publishing a post can require more than clearing the single post URL: the home page, category archives, feeds, menus, related-content blocks, CDN objects, and browser-held assets may all need invalidation.
Purge in the correct order
- Clear the WordPress page-cache plugin, if it owns the HTML.
- Purge the host’s reverse-proxy or full-page cache.
- Purge the CDN’s affected URLs or cache zone.
- Hard-refresh or clear the browser cache when CSS, JavaScript, or images changed.
- Open the page in a logged-out private window and verify the new response.
If the same old page returns after every purge, inspect which layer’s response headers identify the cache authority. A host-level cache can repopulate an emptied plugin cache, and a CDN can continue serving an object that the origin has already regenerated.
Free tools Windows power users keep installed
One-click scans. No signup required.
Common change-specific fixes
- New or edited post: purge the post and affected archives or home-page cache.
- Menu, widget, or template change: purge all HTML pages that render the changed component.
- CSS or JavaScript change: purge the page cache and CDN, then ensure the asset URL changes or its browser freshness policy allows revalidation.
- Plugin or theme setting change: clear generated HTML and any object cache that stores the old setting.
- Logged-in preview looks correct but public page does not: test logged out; the preview may bypass cache while the public response remains stale.
Troubleshoot cache failures
The plugin reports that caching is disabled
- Return to Settings → WP Super Cache and confirm that caching is enabled and saved.
- Check whether the cache directory is writable under the permissions configured by your host.
- Look for a host-managed page cache that is expected to remain the sole authority.
- Check whether another plugin is rewriting the same rules or headers.
Every request appears uncached
- Test while logged out; logged-in cookies can intentionally bypass the page cache.
- Inspect whether the URL sets a session or personalization cookie.
- Check exclusion rules for an overly broad path, cookie, or query-string pattern.
- Ask the host whether its reverse proxy bypasses caching for your domain or response status.
Private data appears in a public response
Stop serving that URL from the shared cache immediately. Add the URL and its identifying cookies to the page-cache and reverse-proxy exclusions, send WordPress no-cache headers with nocache_headers(), purge every affected layer, and test from a separate logged-out browser. Do not treat a cache hit as a success if the response contains account, cart, or user-specific information.
Changes appear only after an unexplained delay
Map every cache layer and its time-to-live. Purge the plugin, host, CDN, and browser as appropriate, then compare headers from a private window. If a response contains a positive max-age, the browser or an intermediary may be correctly retaining it until that lifetime expires.
Best Value
Performance expectations and measurement
The WordPress Advanced Administration Handbook calls caching “the fastest way to improve performance” and says it “can improve performance several hundred times over for fairly static pages.” That is documentation language, not a controlled benchmark or a promise for every WordPress installation. The result depends on page complexity, database work, hosting, network distance, cache-hit rate, and the number of dynamic components.
Measure your own site before and after enabling a cache. Compare the same public URL while logged out, record response headers and server timing, and test a representative post, archive, search result, and dynamic page. A faster anonymous page is not an improvement if checkout, account pages, previews, or personalization stop working correctly.
The Tool Desk
Outbyte PC Repair FREERepair Windows errors before they cause bigger problemsFix Now →Outbyte Driver Updater FREEScan for outdated or missing drivers - takes under a minuteDriver Scan →Maintenance checklist
- Keep exactly one clearly identified authority for shared page HTML.
- Document where host, plugin, reverse-proxy, CDN, browser, and object caches run.
- Record the purge action for each layer and who can perform it.
- After publishing or changing templates, purge the affected HTML and regenerate key pages.
- After changing static assets, verify browser and CDN behavior as well as origin files.
- Test public pages logged out and private pages logged in after major configuration changes.
- Inspect cache-related headers periodically, including positive
Cache-Control: max-agevalues and any host-specific proxy indicators. - Review exclusions whenever a plugin introduces cookies, accounts, carts, previews, or personalized output.
The Bottom Line
Enable caching by choosing one page-cache owner, generating and testing public responses while logged out, configuring browser headers for static assets, and purging every affected layer after changes. Keep private and personalized URLs outside the shared cache, and use response headers plus repeat GET requests to verify what visitors actually receive.
Quick Recap
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
