Platform Adoption Metrics

Building a platform is not enough — you must measure whether teams actually use it, whether it makes them faster, and whether it reduces cognitive load. Without adoption metrics, platform teams operate on assumptions. With them, they operate on evidence.

---

Metric Categories

1. Adoption Metrics (Are teams using it?):
   - % of teams onboarded to platform
   - % of services deployed via platform
   - Feature adoption rates per tool
   - Time-to-first-deployment for new teams
   
2. Productivity Metrics (Is it making teams faster?):
   - DORA metrics: Deployment frequency, lead time, MTTR, change failure rate
   - Time from commit to production
   - Developer wait time (builds, deployments, environment provisioning)
   
3. Satisfaction Metrics (Do developers like it?):
   - Developer Net Promoter Score (dNPS)
   - Support ticket volume and themes
   - Self-service vs ticket ratio
   - Platform-team-to-developer ratio
   
4. Reliability Metrics (Is the platform stable?):
   - Platform availability (SLA/SLO)
   - Incident count caused by platform
   - Mean time to resolve platform issues

---

DORA Metrics Dashboard

class DORAMetricsCollector:
    def deployment_frequency(self, team: str, period_days: int = 30):
        """How often does this team deploy to production?"""
        deployments = self.get_deployments(team, period_days)
        
        return {
            "total_deployments": len(deployments),
            "per_day": len(deployments) / period_days,
            "rating": self.rate_deployment_frequency(len(deployments) / period_days),
        }
    
    def lead_time_for_changes(self, team: str, period_days: int = 30):
        """Time from first commit to production deployment."""
        changes = self.get_changes(team, period_days)
        
        lead_times = [
            (c.deployed_at - c.first_commit_at).total_seconds() / 3600
            for c in changes
            if c.deployed_at
        ]
        
        return {
            "median_hours": statistics.median(lead_times),
            "p90_hours": self.percentile(lead_times, 90),
            "rating": self.rate_lead_time(statistics.median(lead_times)),
        }
    
    def change_failure_rate(self, team: str, period_days: int = 30):
        """% of deployments that cause a failure in production."""
        deployments = self.get_deployments(team, period_days)
        failures = [d for d in deployments if d.caused_incident]
        
        rate = len(failures) / len(deployments) if deployments else 0
        return {
            "rate": rate,
            "failures": len(failures),
            "total": len(deployments),
            "rating": self.rate_change_failure(rate),
        }
    
    def mttr(self, team: str, period_days: int = 30):
        """Mean time to restore service after a failure."""
        incidents = self.get_incidents(team, period_days)
        
        restore_times = [
            (i.resolved_at - i.detected_at).total_seconds() / 3600
            for i in incidents
            if i.resolved_at
        ]
        
        return {
            "median_hours": statistics.median(restore_times) if restore_times else 0,
            "rating": self.rate_mttr(statistics.median(restore_times) if restore_times else 0),
        }
    
    @staticmethod
    def rate_deployment_frequency(per_day):
        if per_day >= 1: return "Elite"
        if per_day >= 1/7: return "High"
        if per_day >= 1/30: return "Medium"
        return "Low"

---

Developer Satisfaction Survey

# Quarterly developer satisfaction survey
questions:
  - id: platform_nps
    type: nps
    question: "How likely are you to recommend our internal platform to a new team?"
    scale: 0-10
  
  - id: time_to_productive
    type: scale
    question: "How quickly can a new team member deploy to production?"
    options: ["Same day", "Same week", "2-4 weeks", "1+ month"]
  
  - id: biggest_pain_point
    type: open_text
    question: "What is your biggest pain point with the developer platform?"
  
  - id: self_service
    type: scale
    question: "I can accomplish most tasks without filing a platform support ticket"
    options: ["Strongly agree", "Agree", "Neutral", "Disagree", "Strongly disagree"]

---

Anti-Patterns

Anti-Pattern	Consequence	Fix
Measure only adoption, not impact	Platform used but not helpful	Pair adoption with DORA and satisfaction
Mandate platform use without measuring	Resentment, shadow IT	Earn adoption through value
Survey fatigue	Low response rates, biased data	Short quarterly surveys + passive metrics
No team-level breakdown	Cannot identify struggling teams	Per-team dashboards, targeted enablement
Vanity metrics only	”95% adoption” hides low satisfaction	Balance quantitative + qualitative metrics

Platform metrics exist to answer one question: “Is the platform making engineering teams more effective?” If you cannot answer that with data, you are building a platform on faith.