I recently spent some time looking closer at the new HybridCache implementation in Umbraco to prepare for my presentation at CodeGarden 2026, and the short version is this: it changes more than just the cache layer.
Historically, Umbraco has been very good at keeping published content available in memory. That has made many common developer patterns feel cheap and convenient. Things like traversing content trees, using `.Children()`, `.Descendants()` and resolving references have often just worked without us thinking too much about the cost.
With HybridCache, that mental model changes. The cache is still there, but not everything necessarily lives in memory all the time.
The big win is scalability
The reason for this change is very easy to understand when looking at large Umbraco installations.
Keeping everything in memory can work beautifully for small and medium-sized sites, but it becomes painful when a site has hundreds of thousands of pages, many languages, or very large content structures. Startup time, memory usage and hosting constraints can become real problems.
HybridCache helps by reducing the memory footprint and making startup faster. Instead of loading everything into memory, Umbraco can seed important content and load other content when needed. That is a big architectural improvement.
The cost did not disappear
The interesting part, at least for me as a developer, is that the cost did not vanish. It moved.
Some operations that used to feel almost free can now become more expensive, especially on larger sites. Traversing a large tree, filtering over many children, or resolving many references may trigger more cache lookups or database access than before.
That does not mean HybridCache is bad. Quite the opposite. But it does mean we need to be more intentional about how we build things like menus, listings, sitemaps and search-driven pages.
Use the right tool for the job
One of my main takeaways is that we should stop treating the published content cache as the answer to everything.
For search and filtering, Examine is often a much better fit. For menus, footers and repeated structures, runtime cache or prebuilt DTOs can be a good option. For sitemaps, adding the right data to the index (e.g. URLs) can be much more scalable than traversing the whole content tree.
So the practical message is simple: measure, observe, and choose the right approach based on what the page actually needs to do.
HybridCache gives Umbraco a better foundation for large sites, but it also makes performance patterns more visible. And honestly, that is probably a good thing.
Download the slides
I’ve shared the full slide deck from the presentation if you want to dig into the examples, benchmarks and diagrams in more detail.
[Download the slides link common soon]