What Platform Engineering Is

Platform engineering builds an internal developer platform (IDP): a set of self-service capabilities that let product teams create, deploy and operate software without needing to be experts in every underlying system. The platform team\'s customers are other engineers, and its success is measured by their outcomes, not by the platform\'s feature count.

It is different from classic operations, where a central team handles requests via tickets. In a platform model, the central team builds products (templates, APIs, portals) that teams use without waiting.

Golden Paths

A golden path is a supported way to do a common task that is easier than the alternatives. Examples: "create a new Java REST service", "add a Postgres database", "deploy to production", "add a scheduled job". Properties of a good one:

  • Optional but attractive. Teams can leave the path with justification; they choose it because it saves them work. Mandating a poor path creates shadow platforms.
  • Complete. A new service created from the path comes with CI, container build, deployment, observability, alerts, security scanning and documentation already wired.
  • Opinionated and small. Cover the 80 percent case well instead of every case badly.
  • Owned and versioned. Someone maintains it, and existing services can upgrade to newer versions of the path.

Start With One Path in Six Weeks

  1. Interview 5 to 8 developers and map how a new service reaches production today. Count the steps, tickets and waiting days. This is your baseline.
  2. Pick the most common service type (for example, a stateless HTTP service) and the single most painful step.
  3. Build a template repository containing code skeleton, CI workflow, Dockerfile, deployment manifests, health endpoints, logging and metrics configuration.
  4. Make it self-service. A button, a CLI command or a pull request, but no ticket.
  5. Pilot with one team and watch them use it. Fix what confuses them.
  6. Measure the same baseline and publish the result.

A Catalog Entry (Backstage Example)

Backstage is a popular open-source developer portal. Each service is described by a catalog-info.yaml file in its repository, which lets the portal show ownership, dependencies, documentation and links in one place. This is the common shape of a component entry:

apiVersion: backstage.io/v1alpha1
kind: Component
metadata:
  name: order-service
  description: Creates and tracks customer orders
  annotations:
    github.com/project-slug: acme/order-service
    backstage.io/techdocs-ref: dir:.
  tags: [java, spring-boot]
  links:
    - url: https://grafana.example.com/d/orders
      title: Dashboard
spec:
  type: service
  lifecycle: production
  owner: group:checkout-pod
  system: checkout
  dependsOn:
    - resource:default/orders-db
  providesApis:
    - orders-api

Ownership is the most valuable field: during an incident, "who owns this?" must have a one-click answer. Check the Backstage documentation for the API versions and kinds supported by your release.

A Software Template Skeleton

Templates let developers create a new service from a form. A trimmed Backstage template looks like this:

apiVersion: scaffolder.backstage.io/v1beta3
kind: Template
metadata:
  name: java-service
  title: Java REST service
  description: Spring Boot service with CI, deployment and observability
spec:
  owner: group:platform
  type: service
  parameters:
    - title: Service details
      required: [name, owner]
      properties:
        name:
          title: Name
          type: string
          pattern: "^[a-z][a-z0-9-]{2,40}$"
        owner:
          title: Owner
          type: string
          ui:field: OwnerPicker
  steps:
    - id: fetch
      name: Fetch skeleton
      action: fetch:template
      input:
        url: ./skeleton
        values:
          name: ${{ parameters.name }}
          owner: ${{ parameters.owner }}
    - id: publish
      name: Create repository
      action: publish:github
      input:
        repoUrl: github.com?owner=acme&repo=${{ parameters.name }}

Backstage is not mandatory; the same ideas work with a simple repository template and a script, or with other portals. Start with the template and add a portal only when discoverability becomes the problem.

What a Platform Usually Contains

CapabilitySelf-service examples
Source and buildRepository templates, standard CI workflows, signed images
DeploymentDeclarative deploys (GitOps), preview environments (per-PR environments), progressive delivery
RuntimeNamespaces, quotas, ingress, autoscaling defaults
Data and messagingProvision a database or queue from a form or a manifest
ObservabilityAutomatic metrics, logs, traces and starter dashboards
SecuritySecrets management, scanning, policy checks, identity
CostPer-team cost visibility, budgets, idle resource reports
Documentation and catalogOwnership, runbooks, API docs

Run the Platform as a Product

  • Have a product manager or product-minded lead and a public roadmap based on developer feedback.
  • Treat developers as customers: interviews, surveys, usage analytics, office hours.
  • Write documentation as part of the feature. An undocumented capability does not exist.
  • Offer support with response expectations, and track recurring questions as bugs in the platform.
  • Deprecate deliberately with migration tooling and timelines.
  • Do not build what you can buy or adopt. Compose open-source and managed services; build only the glue and the experience.

Metrics

MetricWhat it tells you
Time from idea to first production deploy of a new serviceDirect measure of path quality (the baseline you captured)
Adoption of golden paths (share of services using them)Whether teams find them worth using
DORA metrics across teamsWhether delivery improves overall
Developer satisfaction (short quarterly survey)Friction you cannot see in logs
Support requests per team per monthWhere self-service is falling short
Time to restore service and incident countEffect on reliability
Cost per service and wasted capacityCost impact of defaults

Common Mistakes

  • Building a portal first. A beautiful catalog on top of a painful process helps nobody. Fix the path, then expose it.
  • Mandating the platform without making it good. You will get workarounds and resentment.
  • Trying to support every language and framework from day one.
  • No product ownership, so the backlog is whoever shouted last.
  • Treating platform work as a cost centre with no outcome metrics, which invites budget cuts.
  • Ignoring agents. Coding agents also benefit from a platform with clear templates, commands and conventions; the context file can reference platform commands directly.

Platform engineering pairs naturally with pod-based teams: pods own their services end to end because the platform removes the undifferentiated work.

Frequently Asked Questions

What is a golden path in platform engineering?

A golden path is a supported, opinionated way to do a common task, such as creating and deploying a new service, that is easier than doing it manually. Teams can leave it with justification, but most choose it because it saves effort.

What is the difference between DevOps and platform engineering?

DevOps is a culture of shared responsibility between development and operations. Platform engineering is a practice that builds self-service products, such as templates and deployment pipelines, so teams can follow DevOps practices without rebuilding the tooling.

Do I need Backstage to do platform engineering?

No. A repository template, a standard CI workflow and a script can be a golden path. Add a developer portal such as Backstage when finding and understanding services becomes the main problem.

How do I know if my platform is successful?

Measure time from idea to first production deploy for a new service, adoption of the golden paths, DORA delivery metrics, developer satisfaction and the number of support requests. Compare against the baseline you captured before building.

How big does a company need to be for a platform team?

There is no fixed threshold, but a dedicated platform team usually pays off once several teams repeat the same infrastructure work. Before that, a few shared templates and conventions maintained by volunteers are enough.