Platform Capabilities Model

📖 Introduction

When I first started building internal platforms, I approached it as a technical problem—pick the right tools, wire them together, and developers would be productive. But after several iterations, I realized that successful platform engineering requires a more holistic view. Technology is just one piece; you also need investment, adoption, governance, and continuous measurement.

Microsoft's Platform Engineering Capabilities Model provides a structured framework for assessing and building platform maturity. It's helped me identify gaps in our platform strategy that pure technical thinking would have missed.

---

🎯 The Six Capabilities

Overview

Capability	Focus	Key Question
Investment	Resources, budget, strategy	How committed is the organization?
Adoption	Onboarding, documentation, support	How easy is it to use the platform?
Governance	Policies, compliance, standards	How do we ensure safety and consistency?
Provisioning & Management	Infrastructure, automation	How do we deliver platform capabilities?
Interfaces	APIs, portals, CLI tools	How do users interact with the platform?
Measurement & Feedback	Metrics, iteration, improvement	How do we know if we're succeeding?

---

💰 Capability 1: Investment

What It Covers

Investment isn't just about money—it's about organizational commitment to platform engineering as a strategic initiative.

Maturity Levels

from dataclasses import dataclass
from enum import Enum
from typing import List, Optional


class MaturityLevel(Enum):
    LEVEL_1 = "Initial"  # Ad-hoc, reactive
    LEVEL_2 = "Developing"  # Some structure
    LEVEL_3 = "Defined"  # Standardized
    LEVEL_4 = "Managed"  # Measured and controlled
    LEVEL_5 = "Optimizing"  # Continuous improvement


@dataclass
class InvestmentAssessment:
    """Assess investment capability maturity."""
    
    # Leadership support
    executive_sponsor: bool
    dedicated_budget: bool
    multi_year_roadmap: bool
    
    # Team investment
    dedicated_platform_team: bool
    team_size: int
    hiring_plan: bool
    
    # Strategic alignment
    aligned_with_business_goals: bool
    documented_strategy: bool
    success_metrics_defined: bool
    
    def assess_maturity(self) -> MaturityLevel:
        """Determine investment maturity level."""
        score = sum([
            self.executive_sponsor,
            self.dedicated_budget,
            self.multi_year_roadmap,
            self.dedicated_platform_team,
            self.team_size >= 3,
            self.hiring_plan,
            self.aligned_with_business_goals,
            self.documented_strategy,
            self.success_metrics_defined,
        ])
        
        if score <= 2:
            return MaturityLevel.LEVEL_1
        elif score <= 4:
            return MaturityLevel.LEVEL_2
        elif score <= 6:
            return MaturityLevel.LEVEL_3
        elif score <= 8:
            return MaturityLevel.LEVEL_4
        else:
            return MaturityLevel.LEVEL_5
    
    def get_recommendations(self) -> List[str]:
        """Get recommendations for improvement."""
        recommendations = []
        
        if not self.executive_sponsor:
            recommendations.append(
                "Secure executive sponsorship to ensure organizational commitment"
            )
        if not self.dedicated_budget:
            recommendations.append(
                "Establish dedicated budget separate from project-based funding"
            )
        if not self.multi_year_roadmap:
            recommendations.append(
                "Create multi-year roadmap to guide platform evolution"
            )
        if not self.dedicated_platform_team:
            recommendations.append(
                "Form dedicated platform team rather than part-time contributors"
            )
        if self.team_size < 3:
            recommendations.append(
                "Expand team to at least 3 members for sustainable operations"
            )
        
        return recommendations


# Assessment example
assessment = InvestmentAssessment(
    executive_sponsor=True,
    dedicated_budget=True,
    multi_year_roadmap=False,
    dedicated_platform_team=True,
    team_size=4,
    hiring_plan=True,
    aligned_with_business_goals=True,
    documented_strategy=False,
    success_metrics_defined=True,
)

print(f"Maturity Level: {assessment.assess_maturity().value}")
print(f"Recommendations: {assessment.get_recommendations()}")

Investment Patterns

Pattern	Description	Indicators
Grassroots	Bottom-up, developer-driven	Limited funding, part-time contributors
Strategic	Top-down, leadership-driven	Dedicated budget, full-time team
Hybrid	Mix of both	Project funding + platform budget

---

📈 Capability 2: Adoption

What It Covers

The best platform is useless if developers don't use it. Adoption focuses on making the platform accessible, understandable, and valuable.

Adoption Funnel

Adoption Metrics

from dataclasses import dataclass
from datetime import datetime, timedelta
from typing import Dict, List


@dataclass
class AdoptionMetrics:
    """Track platform adoption metrics."""
    
    # Awareness
    teams_aware: int
    total_teams: int
    
    # Trial
    teams_tried: int
    avg_time_to_first_use: timedelta
    
    # Active adoption
    teams_actively_using: int
    weekly_active_users: int
    total_users: int
    
    # Depth of adoption
    features_adopted_per_team: Dict[str, int]
    
    # Advocacy
    internal_champions: int
    contributions_from_users: int
    
    @property
    def awareness_rate(self) -> float:
        return (self.teams_aware / self.total_teams) * 100
    
    @property
    def trial_rate(self) -> float:
        if self.teams_aware == 0:
            return 0
        return (self.teams_tried / self.teams_aware) * 100
    
    @property
    def adoption_rate(self) -> float:
        if self.teams_tried == 0:
            return 0
        return (self.teams_actively_using / self.teams_tried) * 100
    
    @property
    def weekly_active_percentage(self) -> float:
        return (self.weekly_active_users / self.total_users) * 100
    
    def generate_report(self) -> str:
        return f"""
Adoption Report
===============

📢 Awareness
- Teams Aware: {self.teams_aware}/{self.total_teams} ({self.awareness_rate:.1f}%)

🧪 Trial
- Teams Tried: {self.teams_tried}
- Trial Rate: {self.trial_rate:.1f}%
- Avg Time to First Use: {self.avg_time_to_first_use.days} days

✅ Active Adoption
- Teams Using: {self.teams_actively_using}
- Adoption Rate: {self.adoption_rate:.1f}%
- Weekly Active Users: {self.weekly_active_users}/{self.total_users} ({self.weekly_active_percentage:.1f}%)

🌟 Advocacy
- Internal Champions: {self.internal_champions}
- User Contributions: {self.contributions_from_users}
"""


# Example
metrics = AdoptionMetrics(
    teams_aware=45,
    total_teams=50,
    teams_tried=35,
    avg_time_to_first_use=timedelta(days=3),
    teams_actively_using=28,
    weekly_active_users=150,
    total_users=200,
    features_adopted_per_team={"service_creation": 28, "env_provisioning": 20, "observability": 15},
    internal_champions=8,
    contributions_from_users=12,
)

print(metrics.generate_report())

Adoption Best Practices

1. Documentation - Clear, searchable, up-to-date

2. Onboarding - Guided first experience

3. Support - Dedicated Slack channel, office hours

4. Champions Program - Identify and empower advocates

5. Feedback Loops - Regular surveys, user interviews

---

🔒 Capability 3: Governance

What It Covers

Governance ensures the platform maintains security, compliance, and consistency while still enabling developer autonomy.

Governance Model

Policy as Code

"""
Governance policies implemented as code.
"""

from dataclasses import dataclass
from typing import List, Optional
from enum import Enum
import re


class PolicySeverity(Enum):
    ERROR = "error"  # Blocks deployment
    WARNING = "warning"  # Logged, reviewed
    INFO = "info"  # Informational only


@dataclass
class PolicyViolation:
    policy_name: str
    severity: PolicySeverity
    message: str
    resource: str
    remediation: Optional[str] = None


@dataclass
class PolicyResult:
    passed: bool
    violations: List[PolicyViolation]


class GovernancePolicy:
    """Base class for governance policies."""
    
    name: str
    severity: PolicySeverity
    
    def evaluate(self, resource: dict) -> PolicyResult:
        raise NotImplementedError


class ImageRegistryPolicy(GovernancePolicy):
    """Ensure container images come from approved registries."""
    
    name = "approved-image-registry"
    severity = PolicySeverity.ERROR
    
    APPROVED_REGISTRIES = [
        "gcr.io/company-project",
        "registry.company.com",
        "docker.io/company",
    ]
    
    def evaluate(self, resource: dict) -> PolicyResult:
        violations = []
        
        # Extract image from Kubernetes deployment
        containers = (
            resource.get("spec", {})
            .get("template", {})
            .get("spec", {})
            .get("containers", [])
        )
        
        for container in containers:
            image = container.get("image", "")
            if not any(image.startswith(reg) for reg in self.APPROVED_REGISTRIES):
                violations.append(PolicyViolation(
                    policy_name=self.name,
                    severity=self.severity,
                    message=f"Image '{image}' is not from an approved registry",
                    resource=resource.get("metadata", {}).get("name", "unknown"),
                    remediation=f"Use images from: {', '.join(self.APPROVED_REGISTRIES)}",
                ))
        
        return PolicyResult(
            passed=len(violations) == 0,
            violations=violations,
        )


class ResourceLimitsPolicy(GovernancePolicy):
    """Ensure containers have resource limits defined."""
    
    name = "resource-limits-required"
    severity = PolicySeverity.ERROR
    
    def evaluate(self, resource: dict) -> PolicyResult:
        violations = []
        
        containers = (
            resource.get("spec", {})
            .get("template", {})
            .get("spec", {})
            .get("containers", [])
        )
        
        for container in containers:
            resources = container.get("resources", {})
            limits = resources.get("limits", {})
            
            if not limits.get("memory"):
                violations.append(PolicyViolation(
                    policy_name=self.name,
                    severity=self.severity,
                    message=f"Container '{container.get('name')}' missing memory limit",
                    resource=resource.get("metadata", {}).get("name", "unknown"),
                    remediation="Add resources.limits.memory to container spec",
                ))
            
            if not limits.get("cpu"):
                violations.append(PolicyViolation(
                    policy_name=self.name,
                    severity=self.severity,
                    message=f"Container '{container.get('name')}' missing CPU limit",
                    resource=resource.get("metadata", {}).get("name", "unknown"),
                    remediation="Add resources.limits.cpu to container spec",
                ))
        
        return PolicyResult(
            passed=len(violations) == 0,
            violations=violations,
        )


class NamingConventionPolicy(GovernancePolicy):
    """Ensure resources follow naming conventions."""
    
    name = "naming-convention"
    severity = PolicySeverity.WARNING
    
    # Pattern: {team}-{service}-{env}
    PATTERN = r"^[a-z]+-[a-z]+-[a-z]+$"
    
    def evaluate(self, resource: dict) -> PolicyResult:
        violations = []
        name = resource.get("metadata", {}).get("name", "")
        
        if not re.match(self.PATTERN, name):
            violations.append(PolicyViolation(
                policy_name=self.name,
                severity=self.severity,
                message=f"Name '{name}' doesn't follow convention",
                resource=name,
                remediation="Use format: {team}-{service}-{env}",
            ))
        
        return PolicyResult(
            passed=len(violations) == 0,
            violations=violations,
        )


class GovernanceEngine:
    """Run governance policies against resources."""
    
    def __init__(self, policies: List[GovernancePolicy]):
        self.policies = policies
    
    def evaluate(self, resource: dict) -> PolicyResult:
        all_violations = []
        
        for policy in self.policies:
            result = policy.evaluate(resource)
            all_violations.extend(result.violations)
        
        # Check if any ERROR severity violations exist
        has_errors = any(
            v.severity == PolicySeverity.ERROR 
            for v in all_violations
        )
        
        return PolicyResult(
            passed=not has_errors,
            violations=all_violations,
        )


# Usage
engine = GovernanceEngine([
    ImageRegistryPolicy(),
    ResourceLimitsPolicy(),
    NamingConventionPolicy(),
])

deployment = {
    "apiVersion": "apps/v1",
    "kind": "Deployment",
    "metadata": {"name": "my-app"},  # Violates naming convention
    "spec": {
        "template": {
            "spec": {
                "containers": [{
                    "name": "app",
                    "image": "nginx:latest",  # Violates registry policy
                    # Missing resource limits
                }]
            }
        }
    }
}

result = engine.evaluate(deployment)
print(f"Passed: {result.passed}")
for violation in result.violations:
    print(f"  [{violation.severity.value}] {violation.message}")
    if violation.remediation:
        print(f"    Remediation: {violation.remediation}")

---

⚙️ Capability 4: Provisioning & Management

What It Covers

How the platform delivers infrastructure, services, and resources to consumers.

Provisioning Patterns

Infrastructure Abstraction

"""
Platform provisioning abstraction layer.
"""

from abc import ABC, abstractmethod
from dataclasses import dataclass
from typing import Dict, Any, Optional
from enum import Enum
import json


class ResourceType(Enum):
    NAMESPACE = "namespace"
    DATABASE = "database"
    CACHE = "cache"
    QUEUE = "queue"
    STORAGE = "storage"


class ResourceStatus(Enum):
    PENDING = "pending"
    PROVISIONING = "provisioning"
    READY = "ready"
    FAILED = "failed"
    DELETING = "deleting"


@dataclass
class ResourceSpec:
    """Generic resource specification."""
    resource_type: ResourceType
    name: str
    team: str
    environment: str
    config: Dict[str, Any]


@dataclass
class ResourceStatus:
    """Resource status information."""
    status: str
    message: Optional[str] = None
    outputs: Optional[Dict[str, Any]] = None


class ResourceProvisioner(ABC):
    """Abstract base for resource provisioners."""
    
    @abstractmethod
    def provision(self, spec: ResourceSpec) -> ResourceStatus:
        pass
    
    @abstractmethod
    def get_status(self, name: str) -> ResourceStatus:
        pass
    
    @abstractmethod
    def delete(self, name: str) -> bool:
        pass


class DatabaseProvisioner(ResourceProvisioner):
    """Provision managed databases."""
    
    TIER_CONFIGS = {
        "development": {
            "instance_type": "db.t3.micro",
            "storage_gb": 20,
            "multi_az": False,
            "backup_retention_days": 1,
        },
        "staging": {
            "instance_type": "db.t3.small",
            "storage_gb": 50,
            "multi_az": False,
            "backup_retention_days": 7,
        },
        "production": {
            "instance_type": "db.r5.large",
            "storage_gb": 100,
            "multi_az": True,
            "backup_retention_days": 30,
        },
    }
    
    def provision(self, spec: ResourceSpec) -> ResourceStatus:
        """Provision a database with tier-based defaults."""
        tier_config = self.TIER_CONFIGS.get(
            spec.environment, 
            self.TIER_CONFIGS["development"]
        )
        
        # Merge user config with tier defaults
        final_config = {**tier_config, **spec.config}
        
        # Validate config
        if spec.environment == "production":
            if not final_config.get("multi_az"):
                return ResourceStatus(
                    status="failed",
                    message="Production databases must be multi-AZ",
                )
        
        # In real implementation, call Terraform/Crossplane/Cloud API
        print(f"Provisioning database: {spec.name}")
        print(f"Config: {json.dumps(final_config, indent=2)}")
        
        return ResourceStatus(
            status="provisioning",
            outputs={
                "host": f"{spec.name}.db.internal",
                "port": 5432,
                "secret_name": f"{spec.name}-credentials",
            },
        )
    
    def get_status(self, name: str) -> ResourceStatus:
        # Check actual status from cloud provider
        return ResourceStatus(status="ready")
    
    def delete(self, name: str) -> bool:
        print(f"Deleting database: {name}")
        return True


class PlatformOrchestrator:
    """Orchestrate resource provisioning."""
    
    def __init__(self):
        self.provisioners: Dict[ResourceType, ResourceProvisioner] = {
            ResourceType.DATABASE: DatabaseProvisioner(),
            # Add more provisioners as needed
        }
    
    def provision(self, spec: ResourceSpec) -> ResourceStatus:
        """Provision a resource using appropriate provisioner."""
        provisioner = self.provisioners.get(spec.resource_type)
        
        if not provisioner:
            return ResourceStatus(
                status="failed",
                message=f"No provisioner for {spec.resource_type.value}",
            )
        
        return provisioner.provision(spec)
    
    def get_status(self, resource_type: ResourceType, name: str) -> ResourceStatus:
        provisioner = self.provisioners.get(resource_type)
        if provisioner:
            return provisioner.get_status(name)
        return ResourceStatus(status="unknown")


# Usage
orchestrator = PlatformOrchestrator()

db_spec = ResourceSpec(
    resource_type=ResourceType.DATABASE,
    name="orders-db",
    team="checkout",
    environment="production",
    config={"engine": "postgres", "version": "15"},
)

result = orchestrator.provision(db_spec)
print(f"Status: {result.status}")

---

🖥️ Capability 5: Interfaces

What It Covers

How developers interact with the platform—APIs, portals, CLI tools, and IDE integrations.

Interface Types

CLI Design

"""
Platform CLI design patterns.
"""

from dataclasses import dataclass
from typing import Optional, List
import argparse
import json


@dataclass
class ServiceCreateOptions:
    name: str
    team: str
    language: str
    template: str = "default"
    database: Optional[str] = None
    cache: bool = False


class PlatformCLI:
    """Platform command-line interface."""
    
    def __init__(self):
        self.parser = argparse.ArgumentParser(
            prog="platform",
            description="Platform Engineering CLI",
        )
        self._setup_commands()
    
    def _setup_commands(self):
        subparsers = self.parser.add_subparsers(dest="command")
        
        # Service commands
        service_parser = subparsers.add_parser("service", help="Service operations")
        service_sub = service_parser.add_subparsers(dest="action")
        
        # platform service create
        create_parser = service_sub.add_parser("create", help="Create new service")
        create_parser.add_argument("--name", required=True, help="Service name")
        create_parser.add_argument("--team", required=True, help="Team name")
        create_parser.add_argument("--language", required=True, 
                                   choices=["python", "go", "typescript"])
        create_parser.add_argument("--template", default="default",
                                   help="Service template")
        create_parser.add_argument("--database", choices=["postgres", "mysql"],
                                   help="Add database")
        create_parser.add_argument("--cache", action="store_true",
                                   help="Add Redis cache")
        
        # platform service list
        list_parser = service_sub.add_parser("list", help="List services")
        list_parser.add_argument("--team", help="Filter by team")
        list_parser.add_argument("--format", choices=["table", "json"], default="table")
        
        # Environment commands
        env_parser = subparsers.add_parser("env", help="Environment operations")
        env_sub = env_parser.add_subparsers(dest="action")
        
        # platform env create
        env_create = env_sub.add_parser("create", help="Create environment")
        env_create.add_argument("--name", required=True)
        env_create.add_argument("--tier", required=True,
                               choices=["development", "staging", "production"])
        env_create.add_argument("--region", default="us-east-1")
        
        # platform env list
        env_list = env_sub.add_parser("list", help="List environments")
    
    def run(self, args: List[str] = None):
        parsed = self.parser.parse_args(args)
        
        if parsed.command == "service":
            return self._handle_service(parsed)
        elif parsed.command == "env":
            return self._handle_env(parsed)
        else:
            self.parser.print_help()
    
    def _handle_service(self, args):
        if args.action == "create":
            options = ServiceCreateOptions(
                name=args.name,
                team=args.team,
                language=args.language,
                template=args.template,
                database=args.database,
                cache=args.cache,
            )
            print(f"Creating service: {options.name}")
            print(f"  Team: {options.team}")
            print(f"  Language: {options.language}")
            print(f"  Template: {options.template}")
            if options.database:
                print(f"  Database: {options.database}")
            if options.cache:
                print(f"  Cache: Redis")
            
            # Call platform API
            return {"status": "created", "service": options.name}
        
        elif args.action == "list":
            services = [
                {"name": "user-api", "team": "identity", "status": "running"},
                {"name": "order-service", "team": "checkout", "status": "running"},
            ]
            
            if args.team:
                services = [s for s in services if s["team"] == args.team]
            
            if args.format == "json":
                print(json.dumps(services, indent=2))
            else:
                print(f"{'NAME':<20} {'TEAM':<15} {'STATUS':<10}")
                print("-" * 45)
                for s in services:
                    print(f"{s['name']:<20} {s['team']:<15} {s['status']:<10}")
    
    def _handle_env(self, args):
        if args.action == "create":
            print(f"Creating environment: {args.name}")
            print(f"  Tier: {args.tier}")
            print(f"  Region: {args.region}")
        elif args.action == "list":
            print("Listing environments...")


# Usage examples:
# platform service create --name user-api --team identity --language python
# platform service list --team identity --format json
# platform env create --name feature-xyz --tier development

---

📊 Capability 6: Measurement & Feedback

What It Covers

How you measure platform success and continuously improve based on feedback.

Key Metrics Categories

Metrics Implementation

"""
Platform measurement and feedback system.
"""

from dataclasses import dataclass, field
from datetime import datetime, timedelta
from typing import Dict, List, Optional
from enum import Enum
import statistics


class MetricCategory(Enum):
    ADOPTION = "adoption"
    VELOCITY = "velocity"
    QUALITY = "quality"
    SATISFACTION = "satisfaction"


@dataclass
class Metric:
    name: str
    category: MetricCategory
    value: float
    unit: str
    timestamp: datetime = field(default_factory=datetime.now)
    target: Optional[float] = None
    
    @property
    def on_target(self) -> Optional[bool]:
        if self.target is None:
            return None
        return self.value >= self.target


@dataclass
class SurveyResponse:
    user_id: str
    timestamp: datetime
    satisfaction_score: int  # 1-10
    nps_score: int  # -100 to 100
    comments: Optional[str] = None
    pain_points: List[str] = field(default_factory=list)


class PlatformMetrics:
    """Collect and analyze platform metrics."""
    
    def __init__(self):
        self.metrics: List[Metric] = []
        self.surveys: List[SurveyResponse] = []
    
    def record_metric(self, metric: Metric):
        self.metrics.append(metric)
    
    def record_survey(self, survey: SurveyResponse):
        self.surveys.append(survey)
    
    def get_adoption_metrics(self) -> Dict[str, float]:
        """Calculate adoption metrics."""
        return {
            "total_users": 245,
            "weekly_active_users": 198,
            "teams_onboarded": 28,
            "total_teams": 32,
            "adoption_rate": 87.5,
            "features_per_team": 4.2,
        }
    
    def get_velocity_metrics(self) -> Dict[str, float]:
        """Calculate velocity metrics."""
        return {
            "time_to_first_deploy_hours": 2.5,
            "avg_deploy_time_minutes": 8.3,
            "deploys_per_day": 142,
            "environment_provision_minutes": 4.5,
            "service_creation_minutes": 15.0,
        }
    
    def get_quality_metrics(self) -> Dict[str, float]:
        """Calculate quality metrics."""
        return {
            "platform_availability": 99.95,
            "change_failure_rate": 2.1,
            "mttr_minutes": 12.0,
            "incidents_per_month": 3,
            "security_issues": 0,
        }
    
    def get_satisfaction_metrics(self) -> Dict[str, float]:
        """Calculate satisfaction metrics from surveys."""
        if not self.surveys:
            return {}
        
        satisfaction_scores = [s.satisfaction_score for s in self.surveys]
        nps_scores = [s.nps_score for s in self.surveys]
        
        return {
            "satisfaction_avg": statistics.mean(satisfaction_scores),
            "satisfaction_median": statistics.median(satisfaction_scores),
            "nps_score": statistics.mean(nps_scores),
            "response_count": len(self.surveys),
        }
    
    def get_pain_points(self) -> Dict[str, int]:
        """Aggregate pain points from surveys."""
        pain_point_counts: Dict[str, int] = {}
        
        for survey in self.surveys:
            for pain_point in survey.pain_points:
                pain_point_counts[pain_point] = pain_point_counts.get(pain_point, 0) + 1
        
        # Sort by frequency
        return dict(sorted(pain_point_counts.items(), key=lambda x: x[1], reverse=True))
    
    def generate_dashboard(self) -> str:
        """Generate metrics dashboard."""
        adoption = self.get_adoption_metrics()
        velocity = self.get_velocity_metrics()
        quality = self.get_quality_metrics()
        
        return f"""
Platform Engineering Dashboard
==============================

📈 ADOPTION
├─ Users: {adoption['weekly_active_users']}/{adoption['total_users']} weekly active
├─ Teams: {adoption['teams_onboarded']}/{adoption['total_teams']} onboarded
└─ Adoption Rate: {adoption['adoption_rate']}%

⚡ VELOCITY
├─ Time to First Deploy: {velocity['time_to_first_deploy_hours']} hours
├─ Avg Deploy Time: {velocity['avg_deploy_time_minutes']} minutes
├─ Deploys/Day: {velocity['deploys_per_day']}
└─ Env Provision: {velocity['environment_provision_minutes']} minutes

🛡️ QUALITY
├─ Platform Availability: {quality['platform_availability']}%
├─ Change Failure Rate: {quality['change_failure_rate']}%
├─ MTTR: {quality['mttr_minutes']} minutes
└─ Monthly Incidents: {quality['incidents_per_month']}
"""


# Usage
metrics = PlatformMetrics()

# Record some survey responses
metrics.record_survey(SurveyResponse(
    user_id="dev1",
    timestamp=datetime.now(),
    satisfaction_score=8,
    nps_score=40,
    comments="Love the self-service, need better docs",
    pain_points=["documentation", "slow builds"],
))

metrics.record_survey(SurveyResponse(
    user_id="dev2",
    timestamp=datetime.now(),
    satisfaction_score=9,
    nps_score=60,
    pain_points=["slow builds"],
))

print(metrics.generate_dashboard())
print("\nTop Pain Points:", metrics.get_pain_points())

---

🎯 Maturity Assessment

Self-Assessment Template

Capability	Level 1	Level 2	Level 3	Level 4	Level 5
Investment	No dedicated team	Part-time contributors	Dedicated team, limited budget	Full team, multi-year roadmap	Strategic investment, executive visibility
Adoption	Grassroots use	Some documentation	Onboarding program	Champions program	Self-sustaining growth
Governance	Ad-hoc policies	Some automation	Policy as code	Continuous compliance	Proactive governance
Provisioning	Manual processes	Scripts	Self-service some resources	Full self-service	Intelligent automation
Interfaces	CLI only	Portal prototype	Full portal	Multi-interface	Integrated ecosystem
Measurement	No metrics	Basic usage stats	KPIs defined	Continuous measurement	Predictive insights

---

✅ Action Items

After assessing your capabilities:

1. Identify gaps - Where are you weakest?

2. Prioritize - What will have the biggest impact?

3. Set targets - Define measurable goals for each capability

4. Create roadmap - Plan incremental improvements

5. Measure progress - Track advancement over time

---

🔗 What's Next?

In Article 8: Developer Portals with Backstage, we'll explore how to build a developer portal using Spotify's Backstage, implementing software catalogs, templates, and plugins.

---

📚 References

• Microsoft Platform Engineering Capabilities Model

• Puppet State of DevOps Report

• CNCF Platform Engineering Maturity Model

• Humanitec Platform Benchmarking