---
title: What is platform engineering?
url: https://www.vmware.com/topics/platform-engineering
description: "Learn about platform engineering: building self-service platforms that abstract away infrastructure complexity for software teams."
---
# What is platform engineering?
Platform engineering is the discipline of designing, building, and operating a self-service application platform that abstracts away infrastructure complexity for everyone who builds and runs software. It supports the full range of an organization’s workloads, like classic enterprise applications, [microservices](https://www.vmware.com/topics/microservices), mobile apps, [edge](https://www.vmware.com/topics/edge-cloud) workloads, and a fast-growing class of AI and agentic applications, so that teams can ship value quickly, safely, and at scale.
## Origins of platform engineering
The discipline emerged to solve a real problem. As DevOps pushed responsibility for [Kubernetes](https://www.vmware.com/topics/kubernetes), networking, identity, and compliance onto application developers, cognitive load became the bottleneck. Platform engineering answered with the [golden path](https://www.vmware.com/topics/golden-paths): paved roads, self-service, and a platform-as-a-product mindset that treats developers as customers. That foundation is now mainstream, and it is also the launch point for the discipline’s next chapter.
Today, platform engineering is being reshaped by a new kind of consumer. AI-assisted development and autonomous agents now request infrastructure, open pull requests, and remediate incidents at machine speed. The platform engineer’s mandate is expanding accordingly: the platform must serve people and machines alike, exposing not just a friendly user interface but a machine-consumable, policy-governed contract. The industry increasingly calls this evolution [Platform Engineering 2.0](https://www.vmware.com/solutions/cloud-infrastructure/platform-engineering).
## Platform Engineering 2.0: Evolving for the agentic era
- **Platform Engineering 1.0** abstracted infrastructure for a human at a portal. Developer as primary user persona.
- **Platform Engineering 2.0** abstracts intent for a population of humans and agents, with people supervising rather than hand-cranking every step.
The first wave optimized for developer self-service through a catalog and a UI. The second optimizes for outcomes requested by developers and trusted automation, governed by policy and grounded in a shared model of the estate. Several drivers are forcing this shift:
- **Agentic consumers:** When an autonomous agent can provision a database or a cluster in seconds, the limiting factor is no longer a human’s ability to navigate a portal. It’s whether the platform can express its capabilities as APIs and enforce guardrails without a person in the loop.
- **AI as a first-class workload:** GPUs, models, and vector and data services are now core platform primitives, not exotic add-ons. Their cost and scaling behavior differ fundamentally from VMs and containers, and the platform has to account for that.
- **Machine-speed economics:** Autonomous workflows can consume resources non-linearly and incur cost even when a run fails. Cost governance must move from after-the-fact reporting to a real-time constraint on behavior.
- **Trust and attribution:** If both people and agents can act on the platform, every action must be authenticated, scoped, and auditable. Identity stops being a human concern and becomes a workload concern.
Note that Platform Engineering 2.0 does not discard many of the 1.0 principles. Paved roads, self-service, and the platform-as-a-product mindset remain foundational. What changes is the primary consumer, from presenting infrastructure to a human, to modeling intent and policy so that humans and machines can both act on the platform safely.
## The five pillars of platform engineering 2.0
Five capabilities define a platform built for the agentic era. The first is load-bearing; the other four depend on it.
1. **AI native platform:** The Internal Development Platform (IDP) becomes an Agentic Development Platform (ADP). AI workloads and AI agents stop being something the platform tolerates and become something the platform is built for. The center of gravity shifts from a catalog optimized for human browsing to a real-time, API-accessible graph of services, dependencies, ownership, service-level objectives, policy, and cost. With this evolution, platforms expose their capabilities as well-described, machine-callable interfaces paired with first-class agent identity so every automated consumer is authenticated, scoped, and attributable.
2. **Multi-persona experience:** Enterprise-wide agentic autonomy. Every persona, including humans and AI agents, gets purpose-built tools, abstractions, and intelligence.
3. **Embedded FinOps:** FinOps moves out of monthly dashboards and into the provisioning UI and shifts cost visibility from a reporting function to a first-class metric at the moment of action. GPUs, models, vector and data services, and the unit economics of inference become first-class primitives.
4. **Security shifts down:** Guardrails for security, compliance, cost, and operational boundaries are enforced identically whether the actor is a person or an agent. As more decisions are delegated to automation, codified policy becomes the primary safety mechanism rather than human review at every gate. PE 1.0 shifted security left (into the pipeline and onto developers). PE 2.0 keeps shift-left and adds shift-down into the infrastructure substrate itself. Shift-left and shift-down are complementary. And the urgency is real as AI has widened the security gap that shift-left alone cannot close.
5. **Composable by design:** Platform capabilities are delivered as modular, independently deployable, and interchangeable building blocks connected through well-defined contracts (policy, SLAs, APIs) so you can repave the platform quickly. CNCF-conformant or certified options where possible.
## DevOps vs. platform engineering
[DevOps](https://www.vmware.com/topics/devops) is a way of working that combines practices, tools, and culture to improve collaboration between development and operations teams. Platform engineering is the practical manifestation of DevOps at scale: it takes those cultural principles: collaboration, automation, continuous integration, and the discipline of site reliability engineering, and productizes them into a platform that the whole organization consumes. In the 2.0 era, that platform’s consumers include automation as well as people, which raises the bar for APIs, identity, and policy.
| | | |
| --- | --- | --- |
| | **DevOps** | **Platform Engineering** |
| **Definition** | A set of practices that unites software development (Dev) and IT operations (Ops) to ship software faster | The design and operation of a self-service platform, consumed by developers and, increasingly, automation, that hosts applications and services |
| **Focus** | Collaboration between development and operations teams to deliver applications and services | Building and operating a scalable, reliable, policy-governed platform that abstracts intent for humans and machines |
| **Primary consumer** | Development and operations teams working together | Application developers and AI agents requesting capabilities through self-service interfaces and APIs |
| **Main responsibilities** | Automating and streamlining the build, test, and release process
Designing and implementing CI/CD pipelines with development teams Automating and streamlining processes for building, testing, and releasing software | Designing platform architecture and golden paths
Operating and securing the platform as a product
Maintaining a machine-readable system of record
Enforcing policy-as-code for every actor, human or agent |
| **Key skills** | Understanding of both development and operations
Experience with automation tools and technologies
Familiarity with agile and continuous delivery practices | Infrastructure and platform architecture
Designing scalable, reliable platforms and APIs
Infrastructure as code and policy-as-code
Product thinking and developer-experience design |
| **Example job titles** | DevOps Engineer
DevOps Platform Engineer | Platform Engineer
Platform Architect
Platform Product Manager |
## Benefits of platform engineering
Platform engineering accelerates the entire software delivery life cycle (SDLC) by providing the tools, frameworks, and infrastructure that streamline development, testing, and deployment. A well-designed platform improves developer experience, reduces time to production, and increases the consistency and security of how software is built and run which benefits that compound as more of the delivery process is automated.
It does this first by curating tools and frameworks: code repositories, libraries, APIs, IDEs, and version control, so teams spend less time on setup and more on building. Internal developer portals act as a hub for discovering services, templates, and documentation. In a 2.0 platform, that portal is backed by a machine-readable system of record, a catalog or context graph that both people and automation can query, so the same information powers the developer’s screen and the organization’s agents.
It also reduces time to production through infrastructure optimized for [continuous integration and delivery (CI/CD)](https://www.vmware.com/topics/cicd): automated testing and deployment pipelines, containerization, and orchestration that make releases repeatable across environments. And it improves consistency and governance by providing standardized, policy-enforced paths that apply the same security and compliance rules to every team, project, and actor, human or agent. For highly regulated enterprises, that uniform enforcement is what makes self-service and automation safe to adopt at scale.
The strategic payoff: organizations that invest in the context, policy, and tool-catalog substrate now turn scattered AI experimentation into durable institutional capability. The differentiator in the 2.0 era is not who has the most agents, it is who has built the platform that lets developers and automation move quickly and safely on the same paved roads.
## Essentials of platform engineering
A handful of core practices underpin every successful platform and each one extends naturally into the 2.0 era.
**Continuous Integration/Continuous Delivery (CI/CD)** automates the build-test-deploy process at the heart of application delivery, letting developers make changes and see them reflected quickly. Pipelines are typically built on a version control system such as Git plus tooling that automates build, test, and deployment.
**GitOps** is a specific approach to CI/CD that uses Git as the single source of truth for both application code and the infrastructure it runs on. Changes are made by committing to a repository, which triggers automated build, test, and deploy processes. Because every change is versioned and traceable, GitOps is also a natural control point for governing what automation, including agents, is allowed to change.
**Policy-as-code** expresses security, compliance, and operational guardrails as versioned, automatically enforced rules. In a 2.0 platform, it is the primary safety mechanism: it applies the same constraints whether a change originates from a person, a pipeline, or an agent, and it pairs with workload and agent identity so every action is attributable.
**A platform-as-a-product mindset** represents a fundamental shift in how infrastructure and operations (I and O) teams approach their work. Rather than maintaining infrastructure, platform teams focus on the experience of their users and on outcomes. By treating the platform as a product and its consumers as customers, they deliver a competitive [developer experience](https://www.vmware.com/solutions/app-modernization/tanzu-developer-experience) (DevX) and, increasingly, a dependable surface for the automation those developers rely on. The business result is improved developer velocity, stronger security throughout delivery, new efficiencies, and a foundation for innovation.
## Best practices for modern platform engineering
Building a platform for software delivery at scale takes more than the right tools. It takes a platform-as-a-product mindset with a deep focus on the platform’s users (both human and machine). Foundational practices include:
- Adopt a platform-as-a-product mindset, treating developers (and the automation acting on their behalf) as customers
- Establish continuous feedback loops so the platform stays aligned with how its users actually work
- Use data-driven insights to prioritize investments in the platform and its paved roads
- Provide easy onboarding and developer portals that get users productive quickly
Operationally, the following building blocks are put in place as the platform matures:
- Apply infrastructure as code, immutable infrastructure, black-box instrumentation, and service-level indicators
- Implement CI/CD pipelines to automate build, test, and deployment
- Use a container service and Kubernetes to run applications consistently across environments
- Use a service mesh to manage and secure communication between microservices
- Use a centralized management platform to operate, secure, and automate Kubernetes infrastructure
- Implement monitoring, logging, and tracing to track health and performance and to ask new questions of the system
- Scan container images for vulnerabilities continuously, from development to production
- Protect data with backup and restore; cross-cluster restore is valuable for CNCF-conformant clusters
- Use a load balancer to distribute traffic and improve scalability
To extend the platform into the 2.0 era, add the agentic-readiness practices that the five pillars imply:
- Build a machine-readable system of record, an API-accessible graph of services, dependencies, ownership, policy, and cost, so humans and automation share one source of truth
- Expose platform capabilities as well-described, machine-callable interfaces, and establish agent identity so every automated actor is authenticated, scoped, and attributable
- Enforce policy-as-code consistently across people, pipelines, and agents
- Treat AI as a first-class workload with curated primitives for GPUs, models, and data services plus real-time cost controls on autonomous behavior
## The evolution of the platform engineer’s role
The agentic shift reshapes the platform engineer’s job rather than eliminating it. Agents do not supplant platform engineers; they raise the level of abstraction at which engineers work. The work moves from manually building and operating paved roads toward designing the context, contracts, and guardrails that let developers and trusted automation move quickly and safely.
Product thinking, API design, policy authorship, and an understanding of how AI consumes infrastructure become core competencies and titles, such as platform product manager, become as common as platform engineer. The teams that build this substrate now will define the next decade of the discipline; those that bolt AI onto a portal-centric model will spend it firefighting.
## Recommended for You
## How VMware products can help
Application platform engineering is a major focus across [VMware Cloud Foundation (VCF)](https://www.vmware.com/products/cloud-infrastructure/vmware-cloud-foundation) and [VMware Tanzu](https://www.vmware.com/products/app-platform/tanzu) because together they help organizations build, run, and manage modern, cloud native applications that are agile, scalable, and resilient. This matters in today’s digital economy, where businesses must respond quickly to changing customer needs and, increasingly, run AI and agentic workloads alongside their traditional applications on a single, governed foundation.
As the IDP’s substrate, VMware Cloud Foundation provides a unified [private cloud](https://www.vmware.com/topics/private-cloud) platform, integrating compute, storage, networking, and Kubernetes, that lets platform teams run virtual machines, containers, and AI workloads side by side with consistent operations, security, and automation.
## Related Products and Solutions
Layered on top of VCF, VMware Tanzu Platform is an AI-ready application PaaS built on Cloud Foundry that turns private cloud infrastructure into a pre-engineered, elastic application runtime. It automates the entire software lifecycle, from secure container builds and service bindings to automated scaling and unified observability, while abstracting underlying infrastructure complexities. Through simple abstractions, a centralized management interface, and a marketplace for governed data and AI services, platform teams can deliver standardized self-service capabilities for developers, app operators, and agentic AI toolchains. Combined with automated code-to-production workflows, regional capacity pooling, and fleet-wide lifecycle management, Tanzu Platform ensures that both traditional microservices and non-deterministic AI agents remain secure, performant, and compliant by default.
## Recommended for You
- [CI/CD](https://www.vmware.com/topics/cicd)
- [Golden Paths](https://www.vmware.com/topics/golden-paths)
- [DevOps](https://www.vmware.com/topics/devops)
- [Microservices](https://www.vmware.com/topics/microservices)
## Related Products and Solutions
- [VMware Tanzu Platform](https://www.vmware.com/products/app-platform/tanzu)
- [VMware Cloud Foundation](https://www.vmware.com/products/cloud-infrastructure/vmware-cloud-foundation)
- [VMware vSphere Kubernetes Service](https://www.vmware.com/products/cloud-infrastructure/vsphere-kubernetes-service)
## Also of Interest
- [What is DevOps?](https://www.vmware.com/topics/devops)
- [What is Cloud Native?](https://www.vmware.com/topics/cloud-native)
- [Private Cloud Platform Engineering Solutions](https://www.vmware.com/solutions/cloud-infrastructure/platform-engineering)