What Is a Cache Miss? Causes, Types & How to Fix Them
If your website is slow despite a good server and optimised code, cache misses could be the culprit. A cache miss happens when your system goes looking for data in fast-access storage, does not find it, and has to retrieve it from a slower source instead. Every time this happens, your visitors wait a little longer.
This guide explains what a cache miss is, why it happens, the different types you will encounter, and what you can actually do to reduce them, whether you are managing a WordPress site, a web application, or a server environment.
What Is a Cache Miss?
A cache miss occurs when a system attempts to retrieve data from cache memory but the data is not there. As a result, the system has to fall back to a slower, higher-level memory source to fetch what it needs.
To understand this, it helps to understand caching first. A cache is a small, fast layer of storage that sits between your processor or application and the main data source. The idea is simple: store the data you use most frequently somewhere you can reach it quickly, so you do not have to go all the way back to the slower source every time.
When the data is found in cache, it is called a cache hit. When it is not found, that is a cache miss. A cache hit might take 1 to 5 milliseconds. A cache miss might take 50 to 200 milliseconds as the system fetches from main memory, disk, or database. Multiply that across hundreds of page requests and you have a real performance problem.
What Does a Cache Miss Mean for Your Website?
For most website owners, cache misses show up as slow page load times, slow database queries, or a sluggish admin panel. Here are the most common scenarios:
Page cache misses
When a visitor requests a page, your server should ideally serve a pre-built cached version of that page rather than rebuilding it from scratch. A page cache miss means the cached version was not found, so PHP executes, database queries run, templates render, and the full page is assembled before being sent to the visitor. On a well-configured host this takes 200 to 800 milliseconds. A cached page typically responds in 10 to 50 milliseconds.
Database cache misses
Applications like WordPress run multiple database queries per page load. A query cache stores the results of recent queries. A cache miss means the database has to execute the query from scratch rather than returning a stored result, adding latency that compounds across every request.
Object cache misses
Object caching stores the results of expensive PHP operations, such as calculated menus, widget output, or user data, in fast memory like Redis or Memcached. A cache miss forces those operations to run again on every request.
Browser cache misses
When a visitor loads your site, their browser caches static assets like images, CSS, and JavaScript. On repeat visits, the browser serves those from its local cache rather than downloading them again. A cache miss at this level means every asset gets re-downloaded, significantly increasing load time for returning visitors.
CPU cache misses
At the hardware level, processors have their own cache layers (L1, L2, L3) to reduce the time spent waiting on main memory. CPU cache misses are more relevant to compiled applications and low-level software than typical website management, but they underpin all of the above.
The Three Types of Cache Miss
Cache misses are typically categorised into three types. Understanding which type you are dealing with helps determine the right fix.
Compulsory miss (cold start miss)
A compulsory miss happens the first time data is ever requested. Because the cache starts empty, there is nothing to find. This is unavoidable on first load, but can be reduced through prefetching, which is the practice of loading data into cache before it is explicitly requested.
Capacity miss
A capacity miss happens when the cache is full. When new data needs to be stored, old data has to be evicted to make room. If the evicted data gets requested again before it can be re-cached, that is a capacity miss. Increasing cache size or improving cache efficiency reduces these.
Conflict miss
A conflict miss occurs when multiple pieces of data compete for the same cache slot due to how the cache is mapped internally. Even if the cache has available space elsewhere, the specific slot needed is occupied. This is more relevant to CPU-level cache architecture than web application caching.
What Happens During a Cache Miss?
When a cache miss is detected, the following steps typically occur:
- The processor or cache controller detects that the requested data is not in cache
- A cache miss handler is activated to manage the recovery process
- A request is sent to the next level of the memory hierarchy (a higher-level cache, main memory, or database)
- The data is retrieved from that slower source and transferred back
- The cache is updated with the new data, replacing an older entry if needed
- Normal execution resumes, now with the data available in cache for future requests
The total cost of a cache miss is the time spent on all of these steps. At the CPU level, a single L3 cache miss can cost 100 to 300 clock cycles. At the web application level, a database cache miss can add tens to hundreds of milliseconds to a page request.
How to Reduce Cache Misses on Your Website
The approach depends on where the cache misses are occurring. Here are the most effective methods for each layer.
Enable a full-page cache
If you are running WordPress, plugins like LiteSpeed Cache, W3 Total Cache, or WP Rocket can store fully rendered HTML versions of your pages. When visitors request a page, the server returns the cached HTML instantly rather than rebuilding it. This eliminates page cache misses for most traffic.
If your host runs LiteSpeed web server, LiteSpeed Cache (LSCache) integrates directly at the server level for significantly better performance than plugin-only caching. KnownHost includes LiteSpeed and LSCache on all web hosting and managed VPS plans.
Use an object cache with Redis or Memcached
Adding an object cache stores the results of database queries and PHP operations in memory, so they do not have to be recalculated on every request. Redis and Memcached are the two most common solutions. Most managed hosting platforms support both. KnownHost offers Redis and Memcached as options on web hosting and VPS plans.
Set proper cache expiry and cache headers
Browser caching is controlled by cache headers sent by your server. If your headers are too aggressive (expiring content too quickly) or missing entirely, browsers will re-request assets on every visit. Setting long cache lifetimes for static assets like images, CSS, and JavaScript files significantly reduces browser cache misses.
Use a CDN for static assets
A Content Delivery Network caches your static files at edge locations around the world. When a visitor in London requests an image from your US-based server, the CDN serves it from its nearest edge node rather than crossing the Atlantic. This reduces both latency and cache misses at the browser and network level.
Increase cache size
If capacity misses are the problem, the most direct fix is increasing the amount of memory allocated to your cache. On a shared hosting plan this is often not possible, but on a VPS or dedicated server you can adjust Redis or Memcached memory allocations, increase the size of OPcache, or allocate more RAM to your database query cache.
Optimise database queries
Cache misses on the database layer can also be reduced by improving the queries themselves. Fewer queries, faster queries, and better use of indexes all reduce the load on the cache layer and lower the impact of any misses that do occur.
Enable OPcache for PHP
PHP normally reads and compiles source files on every request. OPcache stores the compiled bytecode in shared memory so PHP does not recompile the same files repeatedly. An OPcache miss means re-reading and recompiling from disk, adding 50 to 200 milliseconds per request. OPcache is enabled by default on modern PHP installations and should always be active.
For developers: data locality and prefetching
At the application and CPU level, reducing cache misses often comes down to data locality. Accessing data that is stored close together in memory (rather than scattered randomly) improves the chances of cache hits. Prefetching, where the system loads data into cache before it is explicitly requested based on predicted access patterns, also helps with compulsory misses.
How Your Hosting Affects Cache Miss Rates
Caching strategy matters, but the hardware and infrastructure underneath it matters just as much. Cache misses that would be barely noticeable on fast NVMe storage become significant bottlenecks on older SATA drives. A slow database server means cache miss recovery takes longer. A host that over-provisions servers creates resource contention that defeats even a well-configured cache.
KnownHost runs all hosting plans on AMD EPYC 9000 series processors with enterprise NVMe storage. NVMe access times are significantly faster than SATA SSDs, which directly reduces the cost of cache misses at the disk level. Every web hosting and VPS plan includes LiteSpeed with LSCache, Redis and Memcached support, and Imunify360 security. When cache misses do occur, fast underlying hardware means the recovery time is minimal.
If you are consistently seeing cache-related performance issues on your current host, it may be worth evaluating whether the infrastructure is keeping up with your needs. KnownHost includes free migration for new customers, handled by our team with zero downtime.
Looking for hosting built for fast cache performance? KnownHost includes LiteSpeed, LSCache, Redis, and NVMe storage on every plan. View web hosting plans or managed VPS plans.
Frequently Asked Questions
A cache hit means the requested data was found in cache and returned quickly. A cache miss means it was not found and the system had to retrieve it from a slower source. Cache hit rates are used to measure caching efficiency. A high hit rate (above 90%) indicates that caching is working well. A low hit rate suggests the cache is too small, configured incorrectly, or being invalidated too frequently.
For WordPress sites, caching plugins like LiteSpeed Cache and W3 Total Cache include dashboards that show cache hit and miss rates. You can also use browser developer tools to inspect response headers, where a cached response will typically show an X-Cache: HIT header and a fresh response will show X-Cache: MISS. Server-side tools like Redis CLI and the Memcached stats command show hit and miss counts directly.
A cold cache miss, also called a compulsory miss, happens when data is requested for the very first time and the cache is empty. This is unavoidable on initial load and after a cache is cleared or a server is restarted. Prefetching, where the system loads anticipated data into cache proactively, can reduce the impact of cold misses.
A cache miss is not an error in the traditional sense. It is an expected part of how caching works. The goal is to minimise how often misses occur and minimise the cost when they do, not to eliminate them entirely. Some cache misses are unavoidable, particularly on first load or when data changes frequently.
A dirty cache miss, also called a write miss, occurs when a processor tries to write data to a cache line that is marked dirty, meaning it contains modified data that has not yet been written back to main memory. The cache controller must first flush the modified data back to memory before the new data can be written. This extra step adds latency to the write operation.
Yes, cache misses directly affect website speed. A page cache miss means your server rebuilds the page from scratch on every request rather than serving a pre-built cached version. A database cache miss means queries run fresh rather than returning stored results. Object cache misses force expensive PHP operations to re-execute. The combined effect of frequent cache misses on a busy website can be significant, adding hundreds of milliseconds to every page load.
A cache miss and a page fault operate at different levels of the memory hierarchy. A cache miss occurs when requested data is not found in the processor or application cache, requiring a fetch from higher-level memory. A page fault occurs when a memory page is not present in the main memory at all and must be loaded from disk, which is a much more expensive operation. Page faults are typically measured in milliseconds; the cost of loading from disk is orders of magnitude higher than a cache miss at the CPU level.
