Cloud & DevOps

Noisy Neighbors on Shared Servers: Why Netflix Gave Some Containers a VM of Their Own

Netflix gave its most interruption-sensitive jobs a dedicated VM inside Titus after tuning could not stop noisy neighbors. Why not microVMs or gVisor?

Editorial Team / /9 min read
A single shipping container set apart at a port, away from a ship's stacked containers: Netflix gives some jobs a whole VM instead of a shared server.

A container that stays within its CPU and memory quota can still be slowed down by the container next to it. Netflix described exactly that problem in October 2026 and the fix it chose for it: for a small set of jobs, a dedicated virtual machine inside its container platform. The reasoning behind that choice matters more to most infrastructure teams than the choice itself, partly because it is easy to misread as a security story. It is not one.

The post, published on October 22, 2026 on the Netflix Technology Blog and written by Samartha Chandrashekar and Nick Parker, covers Titus, Netflix’s internal container platform. It is a useful companion to the trade-offs we covered in platform engineering and internal developer platforms: a platform team has to decide when a shared setup stops serving one kind of workload, and what to offer instead.

What Titus is, and what goes wrong on a shared server

Titus is Netflix’s platform for running containers, packaged applications that share the operating system of the server they run on. It is built on Kubernetes, and according to InfoQ’s coverage it launches millions of containers a week across tens of thousands of cloud instances. By default it is multi-tenant: containers from many teams sit on the same server, which is what keeps the platform cheap.

Linux already separates much of what those containers use. Control groups cap CPU and memory, other mechanisms shape disk and network traffic. What no cgroup divides is the hardware itself. The processor’s last-level cache and the memory bandwidth are shared, so a neighbor that hammers memory pushes another container’s data out of the cache, and that container slows down without ever exceeding its quota.

The network was the most painful case. According to the post, the traffic shaper takes a global lock, so a container sending a flood of small packets can eat kernel CPU time, trigger TCP retransmissions and cause spikes in tail latency for everyone nearby. Netflix says it tried to reduce this with CPU pinning and detection based on eBPF, and its conclusion, quoted by InfoQ, was that shared-kernel tuning “narrows the gap without closing it.”

Which jobs hurt, and why it is not a security problem

The workloads that suffered most are stateful, high-throughput streaming jobs: managed Apache Flink stream processing, streaming data connectors, and telemetry and logging pipelines. Their weakness is the cost of a hiccup. A job that falls behind may have to restore from a checkpoint and pause for many minutes to catch up, so a brief disturbance becomes an outage that often wakes someone on call.

The post is explicit about what these jobs need, and it is not what an isolation story usually promises. In Netflix’s words: “What these workloads need is resource and performance isolation: a guarantee that a neighbor cannot steal their CPU, cache, memory bandwidth, or network, not protection from a hostile co-tenant.” The mutually distrusting tenants that a security boundary exists for are not the situation here. The containers belong to trusted internal teams, and the goal is a predictable neighbor, not a locked door.

That distinction changes how to read everything else, including the comparison of technologies below.

The options Netflix weighed

Netflix compared four routes, and the post gives a reason against each.

  • Better shared-kernel isolation. Kept as a baseline, but structurally incomplete, since the cache and memory bandwidth remain shared.
  • MicroVMs such as Firecracker and Kata Containers. Hardware virtualization is only available on bare metal or through nested virtualization, which was not ready on the instance types Netflix uses. No managed microVM service exists, so Netflix would have to operate the hypervisor itself, including patching and live migration. Virtualization overhead on CPU and I/O work and the lack of GPU support counted against them too.
  • gVisor. Its interception of system calls in user space taxes exactly the I/O paths the jobs depend on. The open-source project also lags Netflix’s internal version, and maintenance rests in practice on a single vendor.
  • Running directly on EC2. Teams get isolation, but also the host patching, instance choice and sizing that Titus normally handles. Netflix calls the move between Titus and EC2 “a one-way door.”

Firecracker open-source microVM project homepage

Firecracker is AWS’s open-source microVM technology, one of the options Netflix evaluated and set aside.

gVisor architecture guide page explaining its sandboxing design

gVisor is Google’s open-source sandboxing layer, the other technology Netflix considered.

The summary sentence in the post reads: “microVMs and gVisor asked for a large, bespoke investment with real risk in order to approximate something we could get directly: a VM.”

What Netflix built: one job per VM, inside Titus

Single-tenant Titus runs one task per EC2 instance. The application team does not call a new API: eligibility comes from an allowlist managed by the Compute/Platform team, which also fixes the permitted instance families. The autoscaler launches the smallest instance that satisfies the requested CPU, memory and GPU. The scheduler then enforces pod anti-affinity, a priority class that cannot be preempted, and a taint that keeps other workloads off the node. Defragmentation is disabled, so the job is never moved.

Switching a workload into this mode is a configuration change, a label, not a migration. The platform team still owns the host: it still chooses the image, patches it and decides on capacity. That is the part that closes the one-way door: a team gets the isolation without leaving the managed environment.

The post does not publish percentage gains. The reported results are qualitative: the Flink, connector and telemetry teams describe stable operation, without the intermittent interference that was hard to attribute, and jobs are no longer relocated by fleet defragmentation. Netflix measured isolation by running a reference application alone, then next to a deliberately abusive “havoc” container, and comparing retained throughput and P99 latency.

The costs are stated openly. There is a fixed host overhead that weighs heavily on small instances, some capacity is wasted by best-fit sizing, and startup is slower because a new instance must boot and pull the image. Netflix therefore recommends the mode for large, long-running, interruption-sensitive jobs sized close to a node, and advises against it for small or bursty services.

What a team that is not Netflix can take from it

Two ideas travel well. First, name the threat before picking the tool: contention between trusted workloads and hostile tenants are different problems, and a technology chosen for one can be wasted effort for the other. Second, price the boring option. A dedicated VM already exists, is understood and is patched by someone, while a custom lightweight layer is something your team will own indefinitely.

Netflix’s conclusion is specific to its workloads and its instance types, not a verdict on microVMs or gVisor in general. A team that needs hostile-tenant isolation, or one running on bare metal, may weigh the same options differently.

Decision card: give a job that is costly to restart and suffers from noisy neighbors a dedicated VM inside the platform; keep small or bursty services on shared hosts; skip the microVM route when you need GPUs or lack nested virtualization; and treat a hostile tenant as a separate security question this case does not settle

FAQ

What is a noisy neighbor on a shared server?

A noisy neighbor is a workload that uses shared hardware heavily and slows another workload on the same server, even though both stay within their quotas. The shared resources are typically the processor’s last-level cache, memory bandwidth, network locks, disk throughput and kernel locks.

Did Netflix move these jobs to a VM for security reasons?

No. Netflix says the jobs need resource and performance isolation, not protection from a hostile co-tenant. The containers belong to trusted internal teams, and the aim was predictable latency for stateful streaming jobs that are expensive to restart.

Why did Netflix not choose microVMs or gVisor?

For microVMs, hardware virtualization needs bare metal or nested virtualization, which was not ready on its instance types, there is no managed service, and GPUs are not supported. For gVisor, the system-call interception slows I/O-heavy jobs, and the open-source project trails Netflix’s internal version. A plain VM gave the isolation without that bespoke work.

Is single-tenant Titus a product other companies can use?

No. Titus is Netflix’s internal platform, and single-tenant mode is a feature inside it, described in an engineering blog post rather than offered as a product.

Which workloads should get a dedicated VM?

Netflix recommends it for large, long-running jobs that cannot tolerate interruption and are sized close to a node, such as stateful stream processing. It advises against it for small services or services with irregular traffic, because of the fixed host overhead and slower startup.

#containers#virtualization#kubernetes#cloud-infrastructure