Netflix Tudum’s Read Path: Moving from CQRS Caches to RAW Hollow
Netflix describes how an in-memory RAW Hollow store simplified Tudum page reads and reduced reported page-construction time.
On this page

A read-heavy page can accumulate surprising complexity [1] when each request assembles data from several services and caches. Netflix’s engineering account of Tudum describes a useful example: a content-management workflow produced page data consumed by a high-traffic public experience, and the original design’s freshness behaviour was difficult to reason about.
The team first used a familiar command-query responsibility separation (CQRS) approach. Writes flowed through an event pipeline, while read services maintained query-oriented data. For Tudum, this involved Kafka, Cassandra and near-cache layers. Netflix reports that cache refresh timing could leave pieces of a preview at different update points, making the editorial experience harder to predict.
The company later moved this read path to RAW Hollow, using an in-memory, read-only data representation close to the services that assembled pages. Netflix reports reducing a page-construction path from about 1.4 seconds to about 0.4 seconds. That is a result for the system described in the post, not an expected gain for arbitrary web applications.
Why the original path became hard to operate
CQRS can help when write models and read models have different requirements. But every asynchronous boundary adds a freshness interval and another state to observe. A request that combines independently refreshed fragments can show an inconsistent view even when each component is working as designed.
The key question is not whether Kafka or caches are “slow.” It is whether the read model’s update path matches the product’s consistency needs. If editors need to preview a coherent group of changes, per-key refreshes can be a poor fit unless the system coordinates their visibility.
A compact snapshot for reads
Hollow is an open-source Java library [2] Netflix created for distributing read-only datasets to application processes. Rather than asking a service to reconstruct every page from several remote stores, Netflix’s design placed the needed data in an in-memory object model consumed by the read path.
This can reduce remote calls and avoid repeated assembly work. In-memory data also has limits: it must fit the operational model, be published and refreshed reliably, and have a recovery path when consumers lag or restart. The snapshot producer and readers remain part of the system’s correctness story.
Netflix’s post describes RAW as its chosen approach for Tudum. It does not imply a generic “zero-GC” guarantee or mean that all state belongs in memory. Teams should compare data size, update rates, latency targets and failure behaviour before choosing a similar architecture.
Where the pattern fits
A locally available read model is worth considering when an application repeatedly serves a bounded dataset and can tolerate the explicit snapshot-refresh model. It is less compelling when the dataset is too large, updates must be visible transactionally across many services, or memory duplication dominates cost.
The practical lesson is to design the read model around the user-visible consistency requirement. Instrument snapshot age, publication lag and page-level freshness, then test recovery and partial update scenarios. Netflix’s reported latency improvement is one outcome of that redesign; the broader value is a read path whose data and refresh lifecycle are easier to understand.
Freshness is a product contract
For an editorial preview, “eventually consistent” is too vague to guide an editor. A useful contract says what event makes an update eligible, how long a consumer may take to observe it, and what the interface shows while the new state is propagating. A page that combines a title, image and release date should ideally expose a coherent version boundary rather than silently mixing updates.
An immutable or versioned snapshot can make that boundary easier to reason about. The producer publishes a complete state version; consumers move from one known version to another. This does not make publication instant, but it gives monitoring a concrete target: producer version, consumer version and age of the state currently served. It also creates a recovery question: can a consumer bootstrap from a full snapshot if its delta history is unavailable?
The other practical check is memory footprint under realistic object cardinality. Compact representations can reduce overhead compared with ordinary object graphs, but dataset growth, duplicate process memory and garbage collection still matter. Measure resident memory, startup time, update cost and tail latency together. A fast steady-state read is not enough if deployment causes a long cold-start window.
Frequently asked questions
What did Netflix change in the Tudum architecture?
Netflix describes moving a read-heavy page-data path from a CQRS design using Kafka, Cassandra and near caches to a service that reads a local RAW Hollow snapshot. The article focuses on Tudum’s editorial page construction.
What is Hollow?
Hollow is Netflix’s Java library for distributing and consuming read-only in-memory datasets. It provides a structured object model and mechanisms to publish snapshots and deltas; it is not a general replacement for every database.
How much faster did the page become?
Netflix reports that one page-construction path fell from roughly 1.4 seconds to about 0.4 seconds after the change. Those are Netflix’s measurements for its system, not a general performance guarantee.
Does an in-memory snapshot provide immediate consistency automatically?
No. Snapshot publication and consumer refresh still define when updates become visible. The article describes the design Netflix used for its read path; teams must choose freshness and failure behaviour for their own workload.



/* Comments */
Comments are offline right now — we reconnect automatically, nothing is lost.