Expert Platform Engineer

Your dedicated agent for building internal developer platforms, self-service infrastructure, and golden paths that make engineering teams more productive.

When to Use This Agent

Choose Expert Platform Engineer when:

• Building or evolving an internal developer platform (IDP)
• Designing self-service infrastructure provisioning portals
• Creating golden paths and paved roads for common development workflows
• Optimizing developer experience metrics (onboarding time, provisioning speed, DORA metrics)
• Implementing service catalogs with Backstage, Port, or custom solutions

Consider alternatives when:

• You need pure infrastructure provisioning without platform concerns — use a Terraform or cloud-specific agent
• You're focused on CI/CD pipelines only — use a GitOps or DevOps agent
• You need application-level architecture — use a cloud architect agent

Quick Start

Copy
# .claude/agents/platform-engineer.yml
name: Expert Platform Engineer
model: claude-sonnet
tools:
  - Read
  - Write
  - Edit
  - Bash
  - Glob
  - Grep
description: Platform engineering agent for IDP design, self-service infrastructure, and developer experience optimization

Example invocation:

claude "Design a self-service database provisioning workflow that handles PostgreSQL and Redis, with approval gates for production environments"

Core Concepts

Platform Engineering Pillars

Pillar	Description	Key Metrics
Self-Service	Enable devs to provision without tickets	Self-service rate > 90%
Golden Paths	Opinionated, supported workflows	Adoption rate, time-to-production
Service Catalog	Discoverable APIs, services, docs	Coverage, search success rate
Platform APIs	Programmatic access to platform capabilities	API latency < 200ms
Developer Experience	Reduce cognitive load, accelerate delivery	Onboarding < 1 day

Platform Architecture Pattern

┌─────────────────────────────────────────────┐
│           Developer Portal (UI)             │
│    Service Catalog │ Docs │ Self-Service     │
├─────────────────────────────────────────────┤
│              Platform API Layer             │
│   Provisioning │ RBAC │ Cost │ Compliance   │
├─────────────────────────────────────────────┤
│          Infrastructure Abstractions        │
│  Terraform Modules │ Helm Charts │ CRDs     │
├─────────────────────────────────────────────┤
│         Cloud Providers / On-Prem           │
│     AWS │ Azure │ GCP │ Kubernetes          │
└─────────────────────────────────────────────┘

Configuration

Parameter	Description	Default
platform_scope	Target platform areas (portal, apis, infra)	all
cloud_provider	Primary cloud provider	aws
catalog_tool	Service catalog (backstage, port, custom)	backstage
provisioning_target	Max provisioning time	5min
rbac_model	Access control model (abac, rbac, custom)	rbac

Best Practices

1. Start with developer pain points. Survey your teams before building anything. The best platform features solve real friction, not imagined problems. Track adoption metrics to validate you're building the right thing.

2. Build golden paths, not golden cages. Provide opinionated defaults that cover 80% of use cases, but always leave an escape hatch. Developers should choose golden paths because they're faster, not because they're mandated.

3. Treat your platform as a product. Have a roadmap, gather user feedback, measure NPS, iterate in sprints. Internal platforms fail when they're treated as projects with an end date rather than products with continuous evolution.

4. Automate compliance into the platform. Embed security scanning, policy checks, and audit trails directly into provisioning workflows. Compliance should be invisible to developers, not an afterthought they have to bolt on.

5. Design for multi-tenancy from day one. Resource isolation, cost allocation, RBAC boundaries, and quota management are vastly harder to retrofit. Plan your tenant model before writing the first line of platform code.

Common Issues

Developers bypass the platform for manual provisioning. This usually signals the self-service workflow is too slow, too restrictive, or missing a capability they need. Run usability tests on your provisioning flows, add the missing features, and ensure provisioning completes in under 5 minutes. Mandating platform usage without fixing the UX just creates shadow IT.

Service catalog becomes stale and untrusted. Catalogs rot when they rely on manual updates. Automate catalog population from source-of-truth systems (git repos, cloud APIs, Kubernetes clusters) and run freshness checks that alert owners when metadata drifts. A stale catalog is worse than no catalog.

Platform team becomes a bottleneck instead of an enabler. This happens when the platform requires platform-team involvement for every change. Shift to a self-service model where platform engineers build capabilities and teams consume them independently. The platform team's job is to build the roads, not drive every car.