Source: Netflix Tech Blog — 2026-08-07
Summary
Part 3 of Netflix's engineering series on its real-time distributed graph system — operating at a scale of roughly 150 billion edges per earlier parts of the series — covers how queries actually get served. A Graph Query Service sits at the entry point, accepting gRPC requests and validating the client's traversal specification, then hands the validated spec off to a separate query execution engine that walks the graph and returns results. It's a pure architecture piece about why Netflix split validation from execution instead of putting both in one service.
Key Takeaways
- This is Part 3 of a Netflix series on a real-time distributed graph operating at roughly 150 billion edges.
- The Graph Query Service is the client-facing entry point and accepts requests over gRPC.
- Its job is scoped narrowly to validating the traversal specification the client submits — not executing the traversal itself.
- A separate query execution engine is responsible for actually walking the graph and returning results, decoupled from the validating front door.
- The split between a thin validating gateway and a dedicated execution engine is the core architectural decision the post focuses on.
Reel Script
Hook (~15-20s, 35-45 words) Netflix's recommendation graph has around a hundred and fifty billion edges. When your client sends a query into something that size, you do not want one service doing both the safety check and the actual traversal. Here's why they split it into two.
Core Concept (~45-90s, 105-200 words) The core idea in this piece is separation of concerns, applied to query serving at serious scale. Netflix put a Graph Query Service in front of everything, and its only job is to accept incoming gRPC requests and validate the traversal specification — basically, checking that the query the client is asking for is well-formed and legitimate before anything expensive happens. It does not walk the graph itself. Once a request passes validation, it gets handed off to a completely separate query execution engine, whose only job is to actually traverse the graph and return results. Why bother splitting these into two services instead of one that does both? Because they have very different scaling and failure characteristics. Validation is cheap, fast, and needs to reject bad input immediately at the edge. Execution against a hundred-fifty-billion-edge graph is the expensive, resource-hungry part. Coupling them means every validation check pays the cost profile of the execution engine, and every execution-engine change risks touching your public-facing entry point.
Hands-On (~45-150s, 105-350 words) Trace the actual request path. A client sends a gRPC call describing a traversal it wants — think "start at this node, follow these edge types, this many hops." That call lands first at the Graph Query Service. This service does not touch the graph data at all yet — its whole responsibility here is validation: is this traversal spec well-formed, is it asking for something reasonable, does it pass whatever checks Netflix has decided belong at the front door. Only after that spec is validated does the Graph Query Service hand it off to the query execution engine — a separate system whose job starts where validation ends. That engine is the one that actually walks the graph, following the traversal the client asked for, and returns the results back through the chain to the client. Two services, two jobs, one clean boundary between them: nothing executes without passing validation first, and validation never touches actual graph traversal. If Netflix needs to scale the execution engine independently — more machines, different hardware profile, because walking a hundred-fifty-billion-edge graph is a different beast than checking whether a request is well-formed — they can do that without touching the gRPC front door client applications actually depend on.
Takeaway (~20-30s, 45-70 words) This is a clean example of not letting your entry point and your heavy lifting live in the same service just because it's convenient. At real scale, that coupling becomes the thing that breaks. If you're designing a query layer over a large graph or dataset, ask whether validation and execution actually need to scale together — usually they don't.