The coherence boundary and immutable keys
What happens to staleness when tiers are not coordinated?
Where the hierarchy crosses the coherence boundary, and what immutability does
The mandatory, coherent tiers (CPU cache, buffer pool) are at the top. The optional, bypassable tiers (local file cache, distributed cache) are lower. Here is the consequence for a multi-tier hierarchy.
When tiers are not coordinated, staleness is not monotonic across the hierarchy. Tier 1 can hold a value older than tier 2's, because their TTLs and invalidation paths are independent. A reader who hits tier 1 sees older data than a reader who misses tier 1 and hits tier 2. This is the mechanism behind a very common bug: purging the CDN but not the application cache. It is why "we invalidated it" is an incomplete sentence in any multi-tier system. There is no monotonicity guarantee unless someone built one.
The best single move here
If the key names the exact bytes (a Parquet file at a given snapshot, or a hash of the content), the cached object can never be wrong. It can only be absent. Staleness ceases to be a failure mode. Invalidation ceases to be a mechanism. What is left is a pure problem of What makes data cacheable: reuse distance, size and tier placement.
This is why local file caches over immutable object storage are the highest-value, lowest-risk caching in the modern data stack. It also means that a table format's append-only discipline is a caching enabler, not only a transaction mechanism. As always, the cost was not removed. It was prepaid upstream, as write amplification and janitorial work (compaction, removing orphan files).
A boundary note
t_hit is not a constant of a tier. It depends on the layout inside the tier. A hit into a pointer-chasing structure is worth far less than a hit into a contiguous columnar buffer, because the top tier's effective latency depends on how much of each 64-byte CPU cache line is useful. Hardware physics and data-layout decisions therefore set the t_hit used by this mechanism. This is granularity mismatch reaching up two levels.
In one sentence: uncoordinated tiers give non-monotonic staleness; content-addressed keys over immutable data delete the coherence problem and leave only capacity.