Netflix has detailed the architectural redesign of its real-time service dependencies map, known as Service Topology, to handle production-scale operations. The company outlined the changes in a technical post, explaining how the streaming pipeline now separates intermediary resolution from enrichment and persistence, while also adopting new methods for data transfer and backpressure management.
The update addresses the growing complexity of Netflix’s microservices environment, where thousands of services interact in real time. Service Topology provides a live view of these dependencies, which is critical for troubleshooting and operational visibility.
Three-Stage Pipeline Design
The redesigned system uses a three-stage architecture. The first stage handles intermediary resolution, which identifies the direct and transitive dependencies between services. The second stage manages enrichment, adding metadata and contextual information to the resolved relationships. The third stage handles persistence, storing the enriched topology data for query and analysis.
This separation allows each stage to be scaled independently, reducing bottlenecks and improving overall throughput. Netflix engineers noted that this modular approach also simplifies maintenance and testing.
Backpressure Propagation to Kafka
One key improvement involves backpressure handling. Instead of dropping records when downstream consumers are slow, the system now propagates backpressure upstream to Kafka, the messaging platform used for streaming data. This ensures no data is lost and maintains system stability under variable load.
The approach contrasts with common practices that discard excess messages to avoid overwhelming consumers. Netflix’s solution prioritizes data completeness, which is essential for accurate dependency mapping.
Switch from gRPC to Server-Sent Events
For high-volume internal data transfers, Netflix replaced gRPC with Server-Sent Events (SSE). SSE allows a server to push updates to clients over a single HTTP connection, which is simpler and more efficient for real-time, one-way data streams.
The change reduces overhead compared to gRPC, which is designed for bidirectional communication and requires additional setup. Netflix said the shift has improved throughput and reduced latency in the topology data flow.
These modifications were made to support the scale of Netflix’s production environment, which handles millions of streaming sessions and vast amounts of operational data daily. The company has not announced any impact on user-facing features, but rather internal operational tools.
Broader Implications for Microservices Management
Netflix’s approach offers a reference for other organizations managing complex microservices architectures. The use of SSE for high-volume transfers and Kafka-based backpressure could be adopted by other companies facing similar scaling challenges.
Industry observers note that the separation of concerns in the pipeline is a best practice that can improve resilience and scalability. The details are published in a technical blog post by Eran Stiller, a Netflix engineer.
The company has not indicated when further updates to Service Topology will be made, but the new architecture is already in use in production. Netflix continues to evolve its infrastructure to meet growing demand and maintain service reliability.
