The feedback loops behind Kubernetes — PlanetScale
A PlanetScale engineer breaks down the control loops under Kubernetes by walking through the 'gaps' from running Postgres in a single container to a distributed controller. The piece argues Kubernetes operators are just visible implementations of a classic feedback loop (like a thermostat or cruise control), and asks us to start by ignoring Kubernetes entirely while the loop is built by hand first.
Transcript
Justy Okay, so this PlanetScale post drops a seriously underrated reframe — operators aren’t just YAML deployments, they’re control loops.
Cody Mm-hm.
Justy That’s the whole show
Cody That’s the thesis.
Justy Yeah, like a thermostat or cruise control, but for a database. I sat here thinking I knew what an operator did … and suddenly I see the gap between my laptop Postgres and a production RDS instance is literally the same loop under different names.
Cody Hm.
Justy I mean, it’s kind of obvious once it clicks. You’re reconciling desired state every few seconds. The article walks through the manual version — pick a node, provision a disk, mount it, start Postgres, hope the disk doesn’t fill up — and then lines it up with the operator pieces. That’s not Kubernetes magic. It’s control theory wearing a kubectl T-shirt.
Cody Right, right.
Justy So the real takeaway isn’t 'operators are cool' — it’s 'if you’re running stateful systems, you are already running a control loop and you might as well make it visible and debuggable'.
Cody Sure, but the article’s framing overshoots a little.
Justy How so?
Cody Well, Kubernetes didn’t invent feedback loops for databases. Classic HA setups like Pacemaker or DRBD have been doing this since before containers existed. And we’re still hand-resizing EBS volumes in 2026? That’s not the loop automating itself; that’s a manual step wearing cloud CLI gloves.
Justy Fair. But the article isn’t claiming Kubernetes solved everything — it’s saying the operator pattern exposes the loop so we can reason about it.
Cody Sure, I see that. Still… we’re debugging retries, backoffs, and queue lengths in 2026 the way we debugged them in 2016. The loop moved from shell scripts to CRDs, but the shape is the same.
Justy Which means the insight is timeless and the implementation is always going to look pedestrian. That’s the whole point — the loop is boring because it works.
Cody Boring and still full of manual edges, like when your disk fills up and the operator keeps retrying because nobody wired resizing into the loop.
Justy Exactly. The post calls out those edges explicitly. It’s basically saying 'look, here are the seams that break when reality hits; this is where you should spend your engineering time'.
Cody Okay, okay, I’ll grant it’s a helpful way to think about what operators are actually doing under the hood. Not everything is a GenAI hallucination.
Justy Noted.
Cody So who actually needs to read this?
Justy Two groups. One: anyone who maintains operators today — it gives them a vocabulary to talk about retries and backoffs without sounding like mythical creatures. Two: teams who think 'Postgres on Kubernetes is plug-and-play'; the article will scare them into budgeting real time for the control loop plumbing.
Cody Yeah, it’s a great pressure test. The moment your SREs start writing custom reconcilers to keep disks from filling up, you realize the loop isn’t abstract — it’s just a really cranky set of shell scripts in Go.
Justy Or it’s someone’s side project that turned into production.
Cody …which happens more often than we’d like.
Justy Anyway — the article walks through the manual loop, then maps it to the operator pieces: desired state, watches, queues, retries, persistent volumes. You end up with the same control loop, just expressed as Kubernetes CRDs instead of bash one-liners.
Cody And the loop still exposes every seam.
Justy Right. So the takeaway isn’t 'Kubernetes is amazing' — it’s 'stateful workloads need visible feedback loops and operators give you that visibility, whether it lives in a CRD or a fifty-line shell script'.
Cody Fair.
Justy I’ve been staring at Prometheus rules for weeks wondering why they feel so brittle — turns out I was looking at a control loop that’s missing the actuator half of the system.
Cody Oof. You just outed yourself as a secret control-theory enjoyer.
Justy I own it.
Cody Anyway — the article’s best contribution is the 'start by ignoring Kubernetes' exercise. Build the loop by hand on a single box, then let the operator be the visible implementation of that loop. Suddenly the YAML makes sense.
Justy So practical, yet so few people do it.
Cody Yep. We just slap Postgres into a StatefulSet and call it a day.
Cody Still, if you run stateful workloads on Kubernetes, bookmark this post. It’ll save you from rediscovering cruise-control bugs in 2028.
Justy Deal. Coffee’s empty.