Self-Service Infrastructure
Self-service infrastructure lets authorized users request and manage approved computing resources through automated interfaces. Platform teams define the available choices and guardrails, while users receive resources without waiting for each request to be fulfilled manually.
itPlatform engineering and SRE | OpenSkills.info
Course pathWalk it in order
Look it upDip in anytime
Go furtherLeaves this page
Don't Panic
Don't Panic — Self-Service Infrastructure
Self-service infrastructure is the respectable name for replacing a recurring request queue with a supported platform capability. Instead of explaining the same database, environment, or access need to a specialist each time, a requester declares approved intent and the platform carries it toward a usable result. The important word is supported. A form that sends someone an email is still a ticket wearing a nicer hat.
The useful mental model has six stops: discover, request, validate, fulfill, report, and operate. Discovery says what the capability is for. The request captures decisions the user understands, such as service class, placement, owner, or expiry. Validation checks identity, policy, quota, and dependencies before anything starts reproducing at cloud speed. Fulfillment talks to providers. Reporting tells the requester what happened. Operation handles the awkwardly long tail: updates, renewal, drift, deletion, and the occasional resource that exists only halfway.
A capability is therefore more than a portal button. It has a contract, controls, automation, durable state, documentation, support, and an owner. The platform hides provider sequencing and organization-wide defaults, but it must not hide progress or failure. An operation identity and explicit states are useful because provider work can outlive a browser tab, a network connection, or a person’s confidence that clicking retry is harmless.
The first surprise is that creation is the least interesting part. A resource without ownership, expiry, and deletion behavior is not a finished outcome; it is an archaeological site with billing enabled. A retry without idempotency can create a second site beside it. A partial failure can leave the database behind after the deployment fails. This is why the lifecycle belongs in the capability contract, not in a hopeful footnote.
A golden path combines documentation, templates, integrated capabilities, and guardrails for a common outcome. It should be attractive because it works well, not compulsory because it is the only door someone remembered to build. Valid needs outside the path need an exception route, or they will find one anyway and it will be considerably less observable.
Start with the Intro for the full request-to-resource model and the controls behind it. Use Slides when you need the layers and decision points at a glance. Keep the Cheatsheet nearby when designing states, failure handling, and measures. Then try the Practice reference and Exercise: they turn the tidy diagram into a capability contract that has to survive an actual request.
Where this skill leads
Relevant careers
See how this topic contributes to broader role-level skill maps.
Sources
- https://tag-app-delivery.cncf.io/whitepapers/platforms/
Supports
- Platform definition, value, users, capabilities, providers, and thin-layer guidance
- Self-service, golden paths, documentation, interfaces, secure defaults, and cognitive load
- Platform product ownership, user feedback, adoption, implementation risks, and measures
- https://tag-app-delivery.cncf.io/whitepapers/platform-eng-maturity-model/
Supports
- Independent maturity aspects for investment, adoption, interfaces, operations, and measurement
- Contextual maturity decisions, vertical product iteration, and socio-technical balance
- Intrinsic adoption as evidence that platform capabilities provide clear value
- https://backstage.io/docs/features/software-templates/
Supports
- Template discovery, inputs, review, execution, task status, cancellation, failures, and results
- https://opengitops.dev/
Supports
- Declarative, versioned, pulled, and continuously reconciled desired-state principles
- https://www.openpolicyagent.org/docs
Supports
- Policy as code, structured input, policy decisions, and separation of decision from enforcement
- https://google.aip.dev/155
Supports
- Request identifiers, deduplication, safe retries, and idempotency guarantees
- https://github.com/sindresorhus/awesome
Supports
- Required starting point for awesome-list discovery
- https://github.com/toptechevangelist/awesome-platform-engineering
Supports
- Discovery of Kratix, Score, OpenChoreo, and CNOE as platform-engineering ecosystem projects
- https://docs.kratix.io/main/reference/promises/intro
Supports
- Promise APIs, workflows, dependencies, destination rules, and resource fulfillment
- https://docs.score.dev/docs/score-specification/score-spec-reference/
Supports
- Workload definition, containers, services, and resource dependencies
- https://openchoreo.dev/docs/overview/architecture/
Supports
- Modular internal developer platform architecture, planes, APIs, and reconciliation
- https://cnoe.io/docs/overview/technology
Supports
- Community reference patterns and common tools for internal developer platform capabilities
- https://www.puppet.com/about
Supports
- Puppet's 2005 founding to address manual configuration and its infrastructure-as-code role
- https://www.openstack.org/blog/introducing-openstack/
Supports
- OpenStack's July 2010 introduction as an open cloud-computing platform
- https://www.hashicorp.com/en/blog/terraform-announcement
Supports
- Terraform's July 2014 announcement for defining and launching infrastructure
- https://aws.amazon.com/about-aws/whats-new/2015/07/amazon-web-services-launches-aws-service-catalog/
Supports
- AWS Service Catalog's July 2015 launch for organizing approved products
- https://kubernetes.io/blog/2015/11/kubernetes-1-1-performance-upgrades-improved-tooling-and-a-growing-community/
Supports
- Kubernetes 1.0's July 2015 release and subsequent early adoption
- https://www.cncf.io/blog/2021/09/14/crossplane-moves-from-sandbox-to-cncf-incubator/
Supports
- Crossplane's late-2018 open source origin and September 2021 CNCF incubation
- https://engineering.atspotify.com/2020/3/what-the-heck-is-backstage-anyway
Supports
- Spotify's March 2020 Backstage open-source announcement and its role as an infrastructure interface
- https://www.cncf.io/blog/2023/04/11/announcing-a-white-paper-on-platforms-for-cloud-native-computing/
Supports
- April 2023 publication of the CNCF Platforms White Paper
- https://www.cncf.io/blog/2023/11/20/announcing-the-platform-engineering-maturity-model/
Supports
- November 2023 publication of the CNCF platform engineering maturity model
- https://backstage.io/
Supports
- Backstage as a developer-portal option in the product landscape
- https://www.port.io/
Supports
- Port as a developer-portal option in the product landscape
- https://www.cortex.io/
Supports
- Cortex as a developer-portal option in the product landscape
- https://www.opslevel.com/
Supports
- OpsLevel as a developer-portal option in the product landscape
- https://humanitec.com/
Supports
- Humanitec as an internal developer platform option in the product landscape
- https://www.crossplane.io/
Supports
- Crossplane as an infrastructure control-plane option in the product landscape
- https://www.kratix.io/
Supports
- Kratix as an infrastructure control-plane option in the product landscape
- https://aws.amazon.com/servicecatalog/
Supports
- AWS Service Catalog as a cloud service-catalog option in the product landscape
