Skip to content
Skills Library
DevOps & cloud · Planning

platform-engineer

/platform-engineer

Guides platform engineering—internal developer platforms (IDP), golden paths, self-service abstractions, developer portals, paved-road templates, multi-tenant Kubernetes platforms, and platform-as-product practices (roadmap, adoption, platform SLOs). Use when designing or operating a platform for engineering teams, building service scaffolds, standardizing deploy/runtime patterns, integrating Backstage or similar portals, defining platform APIs and contracts, or measuring developer experience—not for one-off VPC or network design (infrastructure-engineer), per-app CI YAML only (devops), releas

Licence
MIT
Last repository change
20.05.2026

Assessment and security

100/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content35 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
6
Scripts
0
HTML comments
0
URLs in SKILL.md
0
Deprecation

No signals detected. Repository changed on 20.05.2026, without references to retired models or APIs.

Licence

MIT, open: use and modify while retaining author attribution.

What it does and when to use it

Guides platform engineering—internal developer platforms (IDP), golden paths, self-service abstractions, developer portals, paved-road templates, multi-tenant Kubernetes platforms, and platform-as-product practices (roadmap, adoption, platform SLOs). Use when designing or operating a platform for engineering teams, building service scaffolds, standardizing deploy/runtime patterns, integrating Backstage or similar portals, defining platform APIs and contracts, or measuring developer experience—not for one-off VPC or network design (infrastructure-engineer), per-app CI YAML only (devops), releas

Original author description

Guides platform engineering—internal developer platforms (IDP), golden paths, self-service abstractions, developer portals, paved-road templates, multi-tenant Kubernetes platforms, and platform-as-product practices (roadmap, adoption, platform SLOs). Use when designing or operating a platform for engineering teams, building service scaffolds, standardizing deploy/runtime patterns, integrating Backstage or similar portals, defining platform APIs and contracts, or measuring developer experience—not for one-off VPC or network design (infrastructure-engineer), per-app CI YAML only (devops), releas

How it works

  1. When to Use
  2. When NOT to Use
  3. Related skills
  4. Core Workflows
  5. When to load references
Original SKILL.md headings · 111 lines, 578 words
SKILL.md preview
---
name: platform-engineer
description: |
  Guides platform engineering—internal developer platforms (IDP), golden paths, self-service
  abstractions, developer portals, paved-road templates, multi-tenant Kubernetes platforms, and
  platform-as-product practices (roadmap, adoption, platform SLOs).
  Use when designing or operating a platform for engineering teams, building service scaffolds,
  standardizing deploy/runtime patterns, integrating Backstage or similar portals, defining
  platform APIs and contracts, or measuring developer experience—not for one-off VPC or network
  design (infrastructure-engineer), per-app CI YAML only (devops), release cutover planning
  (deployment-strategist), security control implementation (information-security-engineer), or
  enterprise-wide system integration ADRs (senior-system-architecture). For hands-on cluster
  add-ons, Helm, and namespace layout on shared clusters, use cluster-deployment-engineer.
---

# Platform Engineer

## When to Use

- Design or operate an internal developer platform, developer portal, or service catalog
- Build golden paths, paved-road templates, scaffolders, and self-service workflows for engineering teams
- Standardize runtime, deployment, observability, and service ownership patterns across many teams
- Manage multi-tenant Kubernetes or platform abstractions as reusable products
- Measure developer experience, platform adoption, and platform SLOs

## When NOT to Use

- Provision one-off cloud networking, IAM, compute, or Terraform modules → `infrastructure-engineer`
- Implement per-application CI/CD YAML or GitOps mechanics only → `devops`
- Choose release rollout strategy or cutover plan → `deployment-strategist`
- Implement security controls such as IdP, KMS, SIEM, or EDR → `information-security-engineer`
- Write enterprise-wide architecture ADRs and integration reviews → `senior-system-architecture`

## Related skills

| Need | Skill |
|---|---|
| Cloud networking, core IaC modules | `infrastructure-engineer` |
| Managed cloud services under platform | `cloud-engineer` |
| Shared CI/CD, GitOps, SRE alerting | `devops` |
| Canary/blue-green rollout decisions | `deployment-strategist` |
| Pipeline and supply-chain security | `devsecops` |
| Platform IAM, KMS, SIEM hooks | `information-security-engineer` |
| Security of product runtime and tenant isolation | `product-infrastructure-security-engineer` |
| Enterprise integration ADRs and review | `senior-system-architecture` |
| Cluster deploy and day-2 K8s ops | `cluster-deployment-engineer` |

## Core Workflows

### 1. Platform as product

Treat the platform like a product with internal customers:

1. Identify user journeys (create service, deploy, observe, rotate secrets)
2. Define **thin** platform APIs—hide complexity, expose safe defaults
3. Set platform SLOs (e.g., scaffold time, deploy success rate, portal uptime)
4. Roadmap from developer interviews and toil metrics
5. Deprecate with migration windows—not breaking teams silently

**See `references/platform_product.md` for SLOs and adoption metrics.**

### 2. Golden paths (paved roads)

**Golden path properties:**

- Opinionated defaults (language, observability, auth, CI template)
- Escape hatches documented for edge cases
- Versioned templates with changelog
- Same path for 80% of services; exceptions require review

```
scaffold → build (shared pipeline) → deploy (standard envs) → operate (shared dashboards/alerts)
```

**See `references/golden_paths.md` for template and exception process.**

### 3. Internal developer platform (IDP)

**Layers:**

| Layer | Examples |
|---|---|
| Portal | Backstage, custom UI |
| Orchestration | Argo CD, Terraform/Crossplane, Helm charts |
| Runtime | K8s namespaces, serverless platform |
| Data | Shared RDS patterns, message buses |

Integrate catalog, docs, templates, and deployment in one discoverable flow.

**See `references/idp_architecture.md` for component diagram and contracts.**

### 4. Multi-tenant Kubernetes platform

- Namespace/tenant isolation; RBAC and network policies
- Quotas, priority classes, and cluster autoscaling
- Standard add-ons: ingress, cert-manager, external-dns, metrics, logging
- Cluster upgrades with tenant communication plan
- Policy admission (OPA/Kyverno) owned by platform

**See `references/platform_kubernetes.md` for tenant checklist.**

### 5. Developer portal and service catalog

- Register services: owner, tier, repo, on-call, dependencies
- Link runbooks, APIs, and SLIs from catalog entries
- Software templates (Cookiecutter, Yeoman, internal CLI) generate compliant repos
- Scorecards for maturity (tests, SLOs, security baseline)

**See `references/developer_portal.md` for catalog fields and template standards.**

### 6. Platform interfaces and versioning

- Publish platform contracts: breaking vs additive changes
- Semantic versioning for charts, modules, and templates
- Changelog and migration guides for each major bump
- Support window for N-1 template versions

## When to load references

- **IDP design** → `references/idp_architecture.md`
- **Templates and paved roads** → `references/golden_paths.md`
- **Backstage / catalog** → `references/developer_portal.md`
- **K8s multi-tenancy** → `references/platform_kubernetes.md`
- **SLOs and adoption** → `references/platform_product.md`
Files in this package (6)
  • SKILL.md 5 KB
  • references/developer_portal.md 1 KB
  • references/golden_paths.md 1 KB
  • references/idp_architecture.md 1 KB
  • references/platform_kubernetes.md 1 KB
  • references/platform_product.md 1 KB

Versions

RepositoryScoreLicence
This page · rade-nugroho/agentic-enteprises-skill100MIT
wonsukchoi/domain-experts100MIT
Navinspire-ia/navin100AGPL-3.0
agentic-swe/agentic-swe100MIT

Database snapshot: 13.11.2026 · package version 924933398982 (SHA-256 digest of the entire package)

Downloads in the last 30 days: 0 · ranking

Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.

Similar skills

  • 100devops-platform-engineering
    Platform engineering expert specializing in internal developer platforms, self-service infrastructure, Backstage service catalogs, GitOps with ArgoCD, and golden path templates. Use for building developer portals and platform-as-a-product.
  • 90devops-platform-engineering
    Use when the user asks about platform engineering, Internal Developer Platform (IDP), Backstage, developer portals, golden paths, developer self-service, platform teams, or internal developer tooling. Do NOT use for: CI/CD pipeline setup (cicd-pipeline), Kubernetes cluster setup…
  • 90internal-developer-platform
    Designs an internal developer platform (IDP) as a product for one customer — engineers — with paved roads, self-service workflows, and abstractions that speed people up without hiding the levers they need during an incident. Use this whenever the user is scoping a platform…
  • 90devops-internal-developer-platform
    Deep dive into IDP design: golden path architecture, platform APIs, Backstage plugin development, software templates, tech docs, service catalog design, platform adoption, and developer experience measurement. Covers: Scaffolder custom actions, catalog entity modeling, Backstage…
  • 100complete-idp-deployment-on-k3s-from-scratch
    Sequences a lightweight Internal Developer Platform deployment on K3s for edge, on-prem, and development contexts where a full Backstage footprint isn't justified: K3s install → a resource-right-sized IDP choice (slimmed single-replica Backstage vs. a hosted no-code catalog…
  • 100platform-engineering
    Use this skill when building or operating internal developer platforms: infrastructure as code, CI/CD, container orchestration, service networking, secrets, and observability, or when shaping platform products, self-service interfaces, adoption evidence, and policy guardrails.…

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.