Opscraft
Platform engineering & Backstage · Lesson 2 of 5 · 5 min read

Golden paths and self-service

Golden paths

A golden path (Spotify's term; Netflix says paved road) is the supported, opinionated way to do a common task: create a service, add a database, set up alerts. It's the easiest path and the one with the best support, but teams may leave it when they have a good reason, accepting more responsibility.

A good "create a new service" golden path, in one click or command:

  1. Creates a repository from a template with the app skeleton, Dockerfile, tests and README.
  2. Adds a CI pipeline that builds, tests, scans, signs and pushes an image.
  3. Creates the deployment manifests and registers the service with GitOps for dev, staging and production.
  4. Sets up the namespace, service account and IAM role, and a basic dashboard and alerts.
  5. Registers the service in the catalogue with its owner.
Enlarge diagramRepositoryfrom templateCI pipelinebuild, test, scan, signDeploy configGitOps for dev, staging, prodIdentitynamespace, SA, IAM roleObservabilitydashboard and alertsCatalogueregistered with owner123456
Figure 1. A golden path for a new service: one request, everything wired up and compliant.
Swipe sideways to see all of it, or tap to open it full screen.

A developer goes from idea to a running "hello world" in production-like environments in under an hour instead of weeks, and every service starts compliant.

Golden paths need maintenance: when the template improves, existing services should benefit too. Use shared reusable workflows, Helm library charts, base images and versioned modules so updates flow out, rather than one-off copies that drift.

Self-service infrastructure

Developers need databases, buckets and queues. Options, from simplest to most abstract:

Approach How a developer asks Trade-off
Terraform modules + pull requests Add a module block (module "orders_db" { source = "platform/rds-postgres" … }) to a repo; CI plans, the platform team or policy approves Familiar and transparent; developers must know some Terraform
Templates in the portal Fill in a form that opens that pull request for them Friendlier; same machinery underneath
Crossplane Apply a Kubernetes object such as kind: PostgresInstance; a Composition creates the RDS instance, subnet group, secret and alarms Kubernetes-native and GitOps-friendly; another control plane to run
AWS Controllers for Kubernetes (ACK) Apply objects mapping directly to AWS resources Less abstraction, AWS-only
AWS Service Catalog Launch an approved CloudFormation product AWS-native; less developer-friendly

Whatever the mechanism, the platform encodes guardrails in the module or composition: encryption on, backups configured, tags applied, sizes limited by environment, network private. Developers choose a few meaningful options (size, engine version, environment); the platform decides the rest.

Enlarge diagramdeveloper asksPostgresInstancesize: smallplatform moduleTerraform orCrossplanecreated for themRDS · encryption ·backups · privatesubnets · tags · alarms ·secretPR or form
Figure 2. Self-service with guardrails: developers state intent, the platform fills in the safe defaults.
Swipe sideways to see all of it, or tap to open it full screen.

A Crossplane-style claim might look like:

apiVersion: platform.example.com/v1alpha1
kind: PostgresInstance
metadata:
  name: orders-db
  namespace: orders
spec:
  size: small            # maps to an instance class per environment
  version: "16"
  backupRetentionDays: 14
  writeConnectionSecretToRef:
    name: orders-db-conn

Abstractions: how much to hide

Too little abstraction leaves developers with all the complexity; too much hides things they need when debugging, and creates a platform only the platform team understands. Good rules:

  • Expose intent (size, environment, criticality) rather than low-level knobs, but let people see what was created underneath.
  • Provide escape hatches: a way to add a custom annotation or raw resource when the abstraction doesn't fit.
  • Build the thinnest viable platform first — perhaps just documentation and a few templates — and add layers only when users need them.