Netflix achieves an 84% cache hit rate for query results by leveraging interval-aware caching in Apache Druid.

The Core Problem: Inefficient Caching for Rolling Time Windows

Netflix's real-time analytics system operates at a monumental scale, managing over 10 trillion rows of data in Apache Druid. This infrastructure supports critical operational, experimental, and monitoring dashboards.

The Use Case: These dashboards frequently query sliding time windows (e.g., "error count over the past 3 hours"). The underlying query logic remains constant, but the time boundary shifts slightly with each refresh (e.g., from [T-3h, T] to [T-2h59m, T+1m]).
The Traditional Flaw: Standard caching systems use the entire query string as the cache key. A minute change in the time window generates a new, unique key. The cache perceives this as a wholly different query, forcing a full recomputation even though the vast majority of the data (the historical part) is identical.
The Consequence: This leads to low cache hit rates, redundant scanning of massive datasets, and excessive computational load on the Druid cluster, creating a significant performance bottleneck.

The Solution: Interval-Aware Caching Architecture

Netflix's innovation decouples the query structure from the time interval, enabling intelligent reuse of intermediate results. The system operates as an external proxy that intercepts and rewrites queries before they reach Druid.

1. Query Decomposition and Aligned Caching

The key insight is to stop caching the final, monolithic query result and instead cache intermediate aggregation results for fixed, time-aligned intervals (e.g., 5-minute buckets).

A query for [T-60m, T] is conceptually broken into 12 cached, 5-minute segments.
When a new, slightly shifted query [T-55m, T+5m] arrives, the cache identifies that the segments for [T-55m, T] are already available.
Only the newest interval ([T, T+5m]) needs to be sent to Druid for computation.
The final result is then merged from the cached historical segments and the newly computed recent segment.

2. Technical Implementation Details

The design incorporates several sophisticated elements to ensure efficiency and correctness:

Cache Key Generation: Keys are generated based on the normalized query template (the aggregation logic) and the specific time-aligned segment, not the full query interval.
Distributed Storage: Cache segments are stored in a distributed key-value store, allowing for scalable and fast retrieval independent of the proxy layer.
Expiration Strategy (TTL): An exponential Time-to-Live (TTL) policy is used. Recent segments have a short TTL to maintain data freshness, while historical segments have a much longer TTL, enabling long-term reuse.
Balance: This strategy precisely balances the trade-off between performance efficiency (maximizing cache reuse) and data accuracy (ensuring recent data is not stale).

Impact and Significance

The results validate the approach's effectiveness:

Dramatically Reduced Load: A 33% reduction in queries dispatched to Apache Druid directly translates to lower infrastructure costs and improved system stability.
Enhanced Performance: An 84% cache hit rate means most user requests are served instantly from the cache, leading to a 66% improvement in P90 query latency.
Operational Efficiency: In some workloads, the data volume processed (result bytes) was reduced by up to 14 times, drastically decreasing computational resource consumption.

Current State and Future Evolution

The system is described as an experimental layer that is continuously evolving. The future roadmap highlights a deeper integration with the ecosystem:

Broader Query Support: Extending support for templated SQL queries used by dashboard tools, reducing dependency on Druid's native query expression language.
Deeper Integration: Exploring the direct integration of interval-aware caching within Apache Druid itself, which could eliminate the external proxy, reduce latency further, and allow for even more optimized query planning by the database.

In essence, Netflix's solution is a classic example of intelligent data architecture. By analyzing the specific access patterns of their applications (