Platform Engineering — Building an Internal Developer Platform That Engineers Actually Use

# Good IDP: Python microservice template
# BUT engineers can also use Go, Node.js, Rust if justified

templates:
  - name: python-microservice
    description: Recommended template
    inputs:
      - name: service_name
      - name: database_type
        type: select
        options: [postgres, mongodb, dynamodb]
      
  - name: go-service # Alternative path
    description: For performance-critical services
    
  - name: rust-service # Another option
    description: For crypto or embedded work

# catalog/services.yaml - Register services in Backstage
apiVersion: backstage.io/v1alpha1
kind: Component
metadata:
  name: order-service
  description: Processes customer orders
  tags:
    - microservice
    - payment
spec:
  type: service
  owner: team-ecommerce
  lifecycle: production
  providesApis:
    - order-api
  consumesApis:
    - payment-api
    - inventory-api
  dependsOn:
    - resource:postgres-main
    - resource:redis-cache

---
apiVersion: backstage.io/v1alpha1
kind: API
metadata:
  name: order-api
spec:
  type: openapi
  owner: team-ecommerce
  definition:
    $text: https://github.com/example/order-service/blob/main/openapi.yaml

# scaffolder-template.yaml - Create new Node.js service
apiVersion: scaffolder.backstage.io/v1beta3
kind: Template
metadata:
  name: create-nodejs-service
  title: Create Node.js Microservice
  description: Generate a new Node.js service with monitoring
spec:
  owner: platform-team
  type: service
  
  parameters:
    - title: Service Details
      required: [serviceName, teamName]
      properties:
        serviceName:
          type: string
          title: Service Name
          description: e.g., payment-service
          
        teamName:
          type: string
          title: Team Name
          enum:
            - team-ecommerce
            - team-payments
            - team-platform
            
        database:
          type: string
          title: Database Type
          enum:
            - postgres
            - dynamodb
            - none
            
  steps:
    - id: fetch
      name: Fetch template
      action: fetch:template
      input:
        url: ./template
        targetPath: ./template-out
        values:
          serviceName: ${{ parameters.serviceName }}
          teamName: ${{ parameters.teamName }}
          
    - id: publish
      name: Publish to GitHub
      action: publish:github
      input:
        allowedHosts: ['github.com']
        description: Generated ${{ parameters.serviceName }}
        repoUrl: github.com?owner=example&repo=${{ parameters.serviceName }}
        
    - id: register
      name: Register in catalog
      action: catalog:register
      input:
        repoContentsUrl: ${{ steps.publish.output.repoContentsUrl }}
        catalogInfoPath: '/catalog-info.yaml'

# Paved Road: Node.js Microservice

## Fastest way to production (5 min setup, 30 min first deploy)

### 1. Generate service from template
Use Backstage template: [Create Node.js Microservice]

### 2. Deploy to staging
```bash
git push origin main  # CI/CD auto-deploys to staging

npm run test:e2e

git tag v1.0.0
git push origin --tags

## Platform Team as Product Team

Treat platform as a product. Measure adoption, feedback, and satisfaction.

```typescript
// platform-metrics.ts - Track IDP health
import { metrics } from '@opentelemetry/api';

const meter = metrics.getMeter('platform-team');

// New services created this month
export const newServicesCreated = meter.createCounter('platform.new_services_created', {
  description: 'New services created via scaffolder',
});

// Engineer satisfaction (quarterly survey)
export const engineerSatisfaction = meter.createGauge('platform.engineer_satisfaction', {
  description: 'Net promoter score for platform',
});

// Time to first deploy
export const timeToFirstDeploy = meter.createHistogram('platform.time_to_first_deploy', {
  description: 'Time from template generation to first production deploy',
  unit: 'minutes',
});

// Template usage
export const templateUsage = meter.createCounter('platform.template_usage', {
  description: 'How often each template is used',
});

# quarterly-survey.yaml - Measure adoption
questions:
  - "How easy is it to deploy a new service? (1-10)"
  - "How much time do you spend on toil? (hours/week)"
  - "Would you recommend the platform to a new hire? (yes/no)"
  
metrics:
  service_adoption: % of new services using templates
  template_usage: % of teams using paved roads
  time_to_deploy: hours from code commit to production
  engineer_satisfaction: NPS score
  
targets:
  service_adoption: > 90%
  template_usage: > 80%
  time_to_deploy: < 2 hours
  engineer_satisfaction: > 50 NPS