In my previous article, I reflected on what I would design differently if I were building an NSX platform today. That piece was about architectural choices: fewer abstractions, clearer boundaries, stronger defaults.
But design decisions are only part of the story. What ultimately matters is who carries responsibility for how the platform behaves once it’s running.
Most of my work still revolves around VMware Cloud Foundation and NSX, but I find myself operating at a different altitude these days. The conversations I’m part of are less about individual features and more about responsibility boundaries, lifecycle, and what the platform should enforce by default. VCF 9 makes those questions harder to ignore.
Deploying a platform is one thing. Owning it is something else entirely, and on VCF 9 the difference is hard to miss.
Defaults and Guardrails
One of the primary responsibilities of a platform engineer on VCF 9 is defining the defaults that everything else inherits. This sounds simple, but it rarely is.
Defaults determine how namespaces are structured, how VPCs are segmented, which isolation patterns are applied automatically, and which policies are enforced without anyone having to ask for them. They define what “normal” looks like.
Most organizations I work with start by optimizing for flexibility. Every team wants options, and every application is treated as unique. Give it a couple of years and the platform turns into a collection of special cases, each one documented somewhere, maybe. A platform engineer has to resist that.
What you’re aiming for is safe autonomy rather than maximum flexibility. Application teams should be able to move quickly within boundaries that are intentional and well understood. If every new workload triggers fresh networking decisions or another round of the same security debate, the platform isn’t giving enough guidance.
VPCs and integrated lifecycle management make it easier to encode these decisions directly into the platform. That doesn’t remove responsibility. It concentrates it. Someone has to decide which choices are available, which are restricted, and which shouldn’t be visible at all, and those decisions shape how the platform behaves far more than any single feature configuration.
Lifecycle Over Provisioning
Provisioning is visible. Lifecycle is not.
Provisioning a workload on VCF 9, whether a VM or a Kubernetes cluster, is increasingly straightforward. Templates exist, policies are predefined, and the automation layer does most of the work. That’s not where the platform engineer earns their keep.
The real work is in lifecycle.
Clusters need upgrading. Supervisor versions change. NSX components evolve. Dependencies shift. Policies that made sense six months ago start to clash with new operating models, and all of it has to happen without breaking what already runs on the platform.
So you end up thinking in failure domains and blast radius. What happens when a management domain upgrade introduces a behavioral change? How isolated are tenant VPCs during an incident? What’s the rollback plan if a network policy update has side effects nobody anticipated?
None of those are provisioning questions.
It’s tempting to optimize for day one. The real complexity shows up in year two and year three, when the platform has grown, ownership has shifted, and the original architects have moved on to other things.
On VCF 9, lifecycle is integrated across compute, storage, networking, and automation. That integration is powerful, but it also means changes ripple across layers. You need to understand those relationships and design for change from the beginning.
Provisioning makes something exist. Lifecycle keeps it running safely.
What the Platform Engineer Is Not Responsible For
Knowing where your responsibility ends matters as much as knowing what you own.
“Platform engineering” easily becomes a catch-all. Anything that sits between infrastructure and applications tends to land on the platform team’s desk, and that ambiguity creates friction quickly.
The platform engineer isn’t responsible for writing application code, designing CI/CD pipelines, tuning individual microservices, or debugging application-level issues. Those belong to other teams.
Nor is the job to design bespoke networking for every workload. If each new application triggers a new NSX policy design session, the platform engineer has quietly drifted into application ownership. Define the patterns once and let teams consume them.
And the platform engineer isn’t a ticket router between compute, storage, and networking. One of the reasons VCF exists is to reduce the fragmentation between those domains. The job is to make them behave coherently, not to hand-coordinate every interaction.
In practice, this means saying “no” at the right time and pushing back when flexibility starts to undermine operability. Most of the customization that causes long-term fragility is well-intentioned, which is exactly why it’s hard to refuse.
Platform engineering means deciding what must be controlled and leaving the rest to the teams that own it.
Closing Thoughts
On VCF 9, the technology stack is mature and the automation layers are capable. Provisioning is no longer the hard part.
Responsibility is.
Defining defaults, designing for lifecycle, setting boundaries, and keeping compute, storage, networking, and automation coherent aren’t glamorous tasks. But they decide whether the platform is still stable and operable years after it was deployed.
That’s what platform engineering on VCF 9 comes down to: owning how the platform behaves long after the build is done.
Leave a Reply