Platform Team Topology Patterns: Organizing Teams for Effective Platform Engineering

# Platform services offered as self-service
apiVersion: platform.company.com/v1
kind: PlatformService
metadata:
  name: managed-postgresql
spec:
  serviceLevel: self-service
  interactionMode: x-as-a-service
  sla:
    availability: "99.95%"
    responseTime: automated
    supportLevel: documentation-first
  interfaces:
    - type: api
      url: https://api.platform.company.com/v1/postgresql
    - type: cli
      command: platform create postgresql
    - type: ui
      url: https://console.platform.company.com
  documentation:
    gettingStarted: https://docs.platform.company.com/postgresql/quickstart
    apiReference: https://docs.platform.company.com/postgresql/api
    examples: https://github.com/company/platform-examples/postgresql

# Collaboration engagement model
apiVersion: platform.company.com/v1
kind: CollaborationEngagement
metadata:
  name: new-capability-development
spec:
  duration: 6-12 weeks
  participants:
    platformTeam:
      - platform-compute-team
      - platform-security-team
    streamAlignedTeam:
      - payments-product-team
  objectives:
    - Develop serverless computing capability
    - Validate with real product use case
    - Create documentation and examples
  successCriteria:
    - Payments team successfully deploys 3 functions
    - Documentation complete and reviewed
    - Capability ready for general availability
  cadence:
    standups: daily
    planning: weekly
    retrospectives: bi-weekly

# Enabling team engagement
apiVersion: platform.company.com/v1
kind: FacilitationEngagement
metadata:
  name: kubernetes-adoption-coaching
spec:
  enablingTeam: platform-enabling-team
  streamAlignedTeam: logistics-product-team
  duration: 4-8 weeks
  objectives:
    - Migrate monolith to microservices
    - Adopt Kubernetes deployment patterns
    - Implement observability practices
  deliverables:
    - Migration plan and timeline
    - Training sessions (3)
    - Reference implementation
    - Troubleshooting runbook
  exitCriteria:
    - Team independently deploys services
    - Monitoring dashboards created
    - On-call rotation established

# Platform abstraction layers
class PlatformAbstraction:
    """
    Reduce cognitive load through progressive disclosure
    """
    
    def __init__(self):
        self.abstraction_levels = {
            'simple': SimplifiedAPI(),
            'standard': StandardAPI(),
            'advanced': AdvancedAPI(),
            'expert': ExpertAPI()
        }
    
    def get_appropriate_interface(self, team_maturity):
        """
        Provide interface matching team capability
        """
        if team_maturity < 0.3:
            return self.abstraction_levels['simple']
        elif team_maturity < 0.6:
            return self.abstraction_levels['standard']
        elif team_maturity < 0.9:
            return self.abstraction_levels['advanced']
        else:
            return self.abstraction_levels['expert']

class SimplifiedAPI:
    """
    Opinionated defaults, minimal configuration
    """
    def deploy_service(self, name, image):
        return platform.deploy(
            name=name,
            image=image,
            # All other settings use smart defaults
        )

class StandardAPI:
    """
    Common configuration options exposed
    """
    def deploy_service(self, name, image, replicas=3, resources=None):
        return platform.deploy(
            name=name,
            image=image,
            replicas=replicas,
            resources=resources or default_resources(),
        )

class AdvancedAPI:
    """
    Full control over deployment configuration
    """
    def deploy_service(self, deployment_spec):
        return platform.deploy(deployment_spec)

class ExpertAPI:
    """
    Direct access to underlying infrastructure
    """
    def deploy_custom(self, raw_manifests):
        return k8s.apply(raw_manifests)

# RFC Template: Platform Feature Proposal

## Metadata
- RFC Number: RFC-2024-015
- Title: Multi-Region Database Replication
- Author: Platform Data Team
- Status: Proposed
- Created: 2024-01-15

## Summary
Enable automatic database replication across multiple regions for high availability.

## Motivation
Product teams require cross-region deployments but lack expertise for database replication.

## Stakeholders
- **Proposed by:** Platform Data Team
- **Consulted:** Platform Security, Platform Networking
- **Informed:** All product teams

## Design
[Detailed technical design]

## Alternatives Considered
[Alternative approaches and why they were rejected]

## Impact Assessment
- **Product Teams:** Simplified multi-region deployments
- **Platform Team:** Additional operational complexity
- **Security:** Enhanced data residency controls
- **Cost:** Estimated $5K/month infrastructure cost

## Implementation Plan
- Phase 1: Prototype (2 weeks)
- Phase 2: Alpha with 2 product teams (4 weeks)
- Phase 3: Beta rollout (4 weeks)
- Phase 4: General availability (2 weeks)

## Success Metrics
- 80% of multi-region deployments use automatic replication
- RPO < 5 minutes
- RTO < 15 minutes

## Open Questions
1. How to handle schema migrations?
2. Conflict resolution strategy?

# Office hours schedule
apiVersion: platform.company.com/v1
kind: OfficeHours
metadata:
  name: platform-office-hours
spec:
  schedule:
    - day: Tuesday
      time: "14:00-15:00 UTC"
      focus: General Q&A
      hosts:
        - platform-core-team
    
    - day: Thursday
      time: "10:00-11:00 UTC"
      focus: Deep Dive Sessions
      hosts:
        - rotating-specialist-team
      topics:
        - week1: Kubernetes Advanced Patterns
        - week2: Security Best Practices
        - week3: Observability Deep Dive
        - week4: Cost Optimization
  
  format:
    duration: 60 minutes
    structure:
      - segment: Open Q&A
        duration: 30 minutes
      - segment: Featured Topic
        duration: 20 minutes
      - segment: Community Announcements
        duration: 10 minutes
  
  participation:
    required: false
    recorded: true
    recordings: https://videos.company.com/platform-office-hours

# Platform team health dashboard
class PlatformTeamMetrics:
    def __init__(self):
        self.metrics = {
            'team_cognitive_load': GaugeMetric(
                name='team_cognitive_load',
                labels=['team', 'capability'],
                description='Team cognitive load score (0-1)'
            ),
            'service_request_volume': CounterMetric(
                name='service_requests_total',
                labels=['team', 'type'],
                description='Number of service requests'
            ),
            'collaboration_time': HistogramMetric(
                name='collaboration_time_hours',
                labels=['team', 'mode'],
                description='Time spent in collaboration mode'
            ),
            'platform_adoption': GaugeMetric(
                name='platform_capability_adoption',
                labels=['capability'],
                description='Adoption rate of platform capabilities'
            ),
            'team_satisfaction': GaugeMetric(
                name='team_satisfaction_score',
                labels=['team'],
                description='Team satisfaction score (1-5)'
            )
        }
    
    def assess_team_health(self, team):
        """
        Comprehensive team health assessment
        """
        return {
            'cognitive_load': self.calculate_cognitive_load(team),
            'collaboration_ratio': self.calculate_collaboration_ratio(team),
            'toil_percentage': self.calculate_toil(team),
            'innovation_time': self.calculate_innovation_time(team),
            'satisfaction': self.get_team_satisfaction(team)
        }
    
    def calculate_cognitive_load(self, team):
        """
        Assess cognitive load based on:
        - Number of technologies owned
        - Complexity of systems
        - Support burden
        - Context switching
        """
        technologies = len(team.owned_technologies)
        complexity = sum(t.complexity_score for t in team.owned_technologies)
        support_tickets = team.support_tickets_per_week
        
        load_score = (technologies * 0.3 + 
                     complexity * 0.4 + 
                     support_tickets * 0.3) / 100
        
        return min(load_score, 1.0)

# Platform capability adoption tracking
apiVersion: platform.company.com/v1
kind: AdoptionMetrics
metadata:
  name: platform-adoption
spec:
  capabilities:
    - name: container-platform
      status: generally-available
      adoptionRate: 0.95  # 95% of teams
      activeUsers: 47
      totalEligibleTeams: 50
      
    - name: cicd-pipeline
      status: generally-available
      adoptionRate: 0.88
      activeUsers: 44
      totalEligibleTeams: 50
      
    - name: service-mesh
      status: beta
      adoptionRate: 0.24
      activeUsers: 12
      totalEligibleTeams: 50
      
    - name: serverless-platform
      status: alpha
      adoptionRate: 0.06
      activeUsers: 3
      totalEligibleTeams: 50
  
  barriers:
    - capability: service-mesh
      barrier: complexity
      severity: high
      affectedTeams: 15
      mitigation: enhanced-documentation
      
    - capability: serverless-platform
      barrier: missing-use-cases
      severity: medium
      affectedTeams: 20
      mitigation: reference-implementations