The Deployment controller turns "I want 3" into three running Pods, whatever happens.

One loop, three situations. The controller never needs to know why the numbers differ; it only closes the gap.

Observed: 2 Pods

+ 1 missing

A node died and took a Pod with it. Desired is 3, actual is 2.

Action: create 1 Pod

Observed: 4 Pods

Someone started an extra Pod by hand that matches the selector. Desired is 3, actual is 4.

Action: delete 1 Pod

Observed: 3 Pods

match

Everything agrees.

Action: do nothing, check again

Controllers are everywhere

Deployment, ReplicaSet, Node, Job, EndpointSlice, PersistentVolume and more. The controller manager runs dozens of loops in one process.

Level-triggered, not edge-triggered

A controller reacts to the current state, not to a single event. If it misses an event or restarts, the next pass still finds the gap.

Controllers compare desired with actual, forever

A controller is a loop: observe the actual state, compare it with the desired state recorded in the API, and act to close the gap. The controller manager is a single process that runs dozens of these loops, one per kind of object: the Deployment controller, the ReplicaSet controller, the Node controller, the Job controller, the EndpointSlice controller and many more.

The three cards show why this design heals itself. With two Pods observed and three desired, it creates one. With four observed it deletes one. With three observed it does nothing and checks again. It does not matter whether the gap came from a crashed node, a human mistake or a bug: the loop does not care about causes.

A subtle but crucial property is that controllers are level-triggered. They act on the current state of the world, not on a stream of events they must never miss. If a controller crashes, is restarted, or loses an event, the next pass simply reads the state again and notices the difference. This is what makes the system robust.

Reveal the scenarios one by one. Gotcha: two controllers fighting over the same field cause endless flapping. A common example is an HPA and a manually set replica count: the autoscaler changes replicas, a GitOps tool reverts it, and so on. Let exactly one system own each field.