Host Commentary

For this Conversations episode, the thing I kept coming back to is that bare metal is not really the story.

The story is that a lot of teams are tired of paying for complexity twice.

First in the bill. Then again in engineering time.

The cloud made infrastructure dramatically easier in a bunch of ways. I do not think anyone who has actually racked servers, waited on hardware, dealt with colo networking, or tried to manage a random pile of machines should pretend the old world was simple. It was not. There is a reason the cloud won. It gave teams APIs, managed services, fast provisioning, easier experimentation, and a way to stop treating every infrastructure change like a procurement project.

But now a lot of teams are far enough into the cloud era that they are seeing the second-order effects.

The bill is one part of it. Bandwidth, managed service pricing, data transfer, always-on environments, overprovisioned Kubernetes clusters, and a bunch of “we’ll clean that up later” infrastructure that somehow becomes permanent.

But the bigger part, at least to me, is the platform complexity tax.

You start with a simple goal. Run the app. Deploy it safely. Scale it. Keep it reliable. Keep cost under control.

Then a few years later, you have Kubernetes clusters, managed databases, object storage, IAM policies, Terraform modules, Helm charts, GitOps controllers, autoscalers, service meshes, CI/CD runners, observability agents, secrets systems, and a platform team trying to make all of that feel like one coherent developer experience.

And sometimes that is the right tradeoff.

But sometimes it becomes this weird situation where the cloud was supposed to make infrastructure easier, and now the team has built a private bureaucracy on top of managed services. Every abstraction has an owner. Every exception has a support path. Every “simple” request turns into a thread with five teams, three Terraform repos, and someone saying, “I think this is handled by the platform.”

That is why I liked this conversation with Jake.

He is not making the lazy “cloud is dead” argument. That argument is boring, and usually wrong. Cloud is not going anywhere. Kubernetes is not going anywhere. Managed services are not going anywhere. For a lot of teams, they are still the correct answer.

But the more useful question is: what are you actually optimizing for?

If the answer is speed of experimentation, global managed services, low operational ownership, and you have the budget for it, the cloud might be the right answer.

If the answer is deep customization, unusual workloads, custom kernel requirements, or very specific infrastructure control, Kubernetes might still be the right answer.

But if the answer is predictable cost, performance density, data sovereignty, simpler primitives, and giving developers a sane path to deploy without building a giant platform engineering machine around it, then private cloud and bare metal start getting a lot more interesting.

Not because bare metal is nostalgic.

Not because racking servers was secretly fun.

It was fun for about four hours. Then it became inventory, cabling, firmware, network weirdness, drive failures, and “who has the crash cart?”

What is interesting now is whether teams can get some of the economic and ownership benefits of bare metal without taking back all of the old operational pain.

That is where platforms like Cycle fit into the conversation. Not as “everyone should use this,” but as an example of a broader shift: teams want the infrastructure underneath them to be simpler, more predictable, and less dependent on a massive pile of glue code.

Jake’s point about opinionated platforms also stood out to me.

As engineers, we love optionality. We like knowing we can customize the thing. We like having access to every dial, every plugin, every escape hatch, every config field, every weird little setting that might matter someday.

But optionality has a cost.

Every knob is a decision. Every decision becomes tribal knowledge. Every deviation becomes something the platform team has to support. And eventually, the platform becomes less of a paved road and more of a choose-your-own-adventure book where half the endings page the on-call engineer.

That does not mean opinionated platforms are always better. Sometimes opinionated tools box you in. Sometimes they hide too much. Sometimes they are great until you hit the edge of the product and suddenly the workaround is worse than the original problem.

But there is a real argument for boring primitives and good defaults.

Especially for teams that mostly need to run containers, maybe some VMs, expose services, attach storage, manage networking, and deploy applications without turning every developer into a part-time infrastructure engineer.

The other part I thought was interesting was the gravity of cloud ecosystems. Even when teams want to move away from a hyperscaler, they may still need to stay near it. Jake mentioned companies wanting bare metal near us-east-1 because the services they depend on are still there. That feels very real. Infrastructure decisions are rarely clean. You can move the workload, but you may not move all the dependencies, all the latency requirements, all the third-party services, or all the operational habits built around the old platform.

That is the part that usually gets missed in the “should we leave the cloud?” conversation.

It is not just, can we run this somewhere else?

It is, what does this thing depend on?

What data does it need?

What services does it call?

What latency does it assume?

What operational model does the team already understand?

What managed services are we actually using, and which ones are just convenience glue we forgot became critical?

That is where the real work is.

So my takeaway from this episode is not “move back to bare metal.”

It is more like: periodically re-check your assumptions.

The cloud decision you made five years ago might still be right. Or it might be right for some workloads and completely wrong for others. Kubernetes might still be the right foundation. Or it might be an expensive control plane for apps that only needed a much simpler runtime. Managed services might be saving your team. Or they might be quietly locking you into cost and operational patterns nobody has revisited in years.

Infrastructure choices age.

Team size changes. Compliance changes. Cost pressure changes. Latency requirements change. The talent on the team changes. The business changes.

And when that happens, “this is how we’ve always done it” is not an architecture strategy. It is just drift with better branding.

That is why I think this private cloud and bare metal conversation is coming back. Not because the industry wants to rewind the clock, but because teams are trying to find a better balance between control and convenience.

More ownership, without becoming hardware janitors.

Better cost predictability, without building everything from scratch.

More performance, without turning the platform into a science project.

More developer self-service, without pretending every team wants to become DevOps experts.

That is the useful middle ground.

And honestly, that is where a lot of the best infrastructure conversations live. Not in declaring one model dead and another one the future, but in being honest about the tradeoffs, the cost, the people, and the operational reality after the architecture diagram becomes production.

Show Notes

This is a guest conversation episode of Ship It Weekly, separate from the weekly news recaps.

In this Ship It: Conversations episode, I talk with Jake Warner, founder and CEO of Cycle.io, about private cloud, bare metal, Kubernetes fatigue, and why some teams are rethinking how much infrastructure complexity they actually want to carry.

We talk about why bare metal and private cloud are getting interesting again, especially around cost, performance, data sovereignty, compliance, and platform ownership. Jake explains how Cycle approaches infrastructure as a pool of resources, why he thinks in terms of “environments as code” instead of traditional infrastructure as code, and how teams can run containers and VMs together across bare metal, cloud, and hybrid environments.

The bigger theme here is that this is not really a “cloud versus bare metal” conversation. It is about choosing the right level of abstraction. Sometimes Kubernetes is the right answer. Sometimes managed cloud services make sense. And sometimes teams just need a more opinionated platform that lets developers ship without requiring a large DevOps army to keep everything running.

Highlights

• Why some teams are moving back toward private cloud and bare metal

• The role of cost, data sovereignty, compliance, and performance in infrastructure decisions

• Why bare metal does not have to mean going back to old-school racking and stacking pain

• How Cycle turns raw compute into a private cloud-style resource pool

• Why Jake thinks about “environments as code” instead of only infrastructure as code

• What “no DevOps army required” means in practice for engineering-heavy teams

• Why some companies need VMs and containers running together on the same platform

• Where Kubernetes still makes sense, especially for highly customized infrastructure needs

• Why opinionated platforms can be valuable when teams want fewer knobs and better defaults

• Active-active thinking, failover risk, and why application-level replication often matters more than platform-level storage magic

• Why bandwidth, performance density, and predictable pricing can make bare metal attractive again

• The weird continued gravity of AWS us-east-1, even for teams trying to move workloads elsewhere

• How AI workloads, GPUs, and hype cycles fit into the private cloud and platform conversation

• Jake’s advice for modernizing hybrid or on-prem infrastructure: containerize first, then look hard at your dependencies

Jake’s links

Cycle.io: https://cycle.io/

• Cycle Slack community: https://slack.cycle.io/

• Jake Warner on LinkedIn: https://www.linkedin.com/in/jakewarner/

Our links

More episodes + show notes + links: https://shipitweekly.fm

On Call Brief: https://oncallbrief.com

Brian Teller
Hosted by
Brian Teller

25 years in production: DevOps, SRE, platform, and cloud. DevOps Institute & ITIL Ambassador.

More about Brian Teller →