Building and Scaling Platform Teams

📖 Introduction

A platform is only as good as the team building and supporting it. Platform engineering requires a unique blend of skills—deep technical expertise combined with product thinking, empathy for developers, and the ability to influence without authority. Building this team is often the hardest part of starting a platform engineering practice.

In my experience, the most successful platform teams share one characteristic: they genuinely care about making developers' lives better. Technical skills can be taught, but that customer-first mindset is essential.

---

🏗️ Team Structure

Platform Team Archetypes

Team Topologies Alignment

Topology	Platform Team Role	Interaction Mode
Stream-aligned teams	Customer of the platform	X-as-a-Service
Platform team	Builds the platform	Providing services
Enabling team	Helps adoption	Facilitating
Complicated subsystem	Deep specialization	Collaboration

---

👥 Team Composition

Core Roles

Role Definitions

"""
Platform team role definitions and skill matrices.
"""

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


class SkillLevel(Enum):
    BASIC = 1
    INTERMEDIATE = 2
    ADVANCED = 3
    EXPERT = 4


@dataclass
class Skill:
    """A skill with required level."""
    name: str
    category: str
    required_level: SkillLevel


@dataclass
class Role:
    """Platform team role definition."""
    title: str
    description: str
    responsibilities: List[str]
    required_skills: List[Skill]
    nice_to_have: List[str]
    
    def format_job_description(self) -> str:
        """Format as job description."""
        lines = [
            f"# {self.title}",
            "",
            self.description,
            "",
            "## Responsibilities",
        ]
        for resp in self.responsibilities:
            lines.append(f"- {resp}")
        
        lines.extend(["", "## Required Skills"])
        for skill in self.required_skills:
            lines.append(f"- {skill.name} ({skill.category}) - {skill.required_level.name}")
        
        lines.extend(["", "## Nice to Have"])
        for item in self.nice_to_have:
            lines.append(f"- {item}")
        
        return "\n".join(lines)


class PlatformTeamRoles:
    """Standard platform team roles."""
    
    PLATFORM_PRODUCT_MANAGER = Role(
        title="Platform Product Manager",
        description="""
        Own the platform roadmap and ensure we're building what developers need.
        Bridge between business stakeholders and the platform engineering team.
        """,
        responsibilities=[
            "Own platform roadmap and prioritization",
            "Conduct developer research and feedback sessions",
            "Define success metrics and track adoption",
            "Communicate platform vision and updates",
            "Manage stakeholder expectations",
            "Balance feature requests with technical debt",
        ],
        required_skills=[
            Skill("Product Management", "Product", SkillLevel.EXPERT),
            Skill("Stakeholder Management", "Soft Skills", SkillLevel.ADVANCED),
            Skill("Data Analysis", "Analytics", SkillLevel.INTERMEDIATE),
            Skill("Technical Communication", "Soft Skills", SkillLevel.ADVANCED),
        ],
        nice_to_have=[
            "Software engineering background",
            "DevOps/SRE experience",
            "Experience with developer tools",
        ],
    )
    
    PLATFORM_TECH_LEAD = Role(
        title="Platform Tech Lead",
        description="""
        Technical leader responsible for platform architecture, standards,
        and technical direction. Mentor team members and ensure quality.
        """,
        responsibilities=[
            "Define platform architecture and technical standards",
            "Lead technical design reviews",
            "Mentor platform engineers",
            "Make build vs buy decisions",
            "Ensure security and reliability requirements",
            "Coordinate with other engineering teams",
        ],
        required_skills=[
            Skill("Kubernetes", "Infrastructure", SkillLevel.EXPERT),
            Skill("Distributed Systems", "Architecture", SkillLevel.EXPERT),
            Skill("Go or Python", "Programming", SkillLevel.ADVANCED),
            Skill("CI/CD Systems", "DevOps", SkillLevel.EXPERT),
            Skill("Technical Leadership", "Soft Skills", SkillLevel.ADVANCED),
        ],
        nice_to_have=[
            "Open source contributions",
            "Experience building developer platforms",
            "Background in multiple cloud providers",
        ],
    )
    
    PLATFORM_ENGINEER = Role(
        title="Platform Engineer",
        description="""
        Build and maintain platform capabilities that enable developer self-service.
        Create abstractions that hide infrastructure complexity.
        """,
        responsibilities=[
            "Develop platform APIs and controllers",
            "Build self-service templates and tooling",
            "Automate infrastructure provisioning",
            "Create and maintain golden paths",
            "Write documentation and tutorials",
            "Provide on-call support for platform issues",
        ],
        required_skills=[
            Skill("Kubernetes", "Infrastructure", SkillLevel.ADVANCED),
            Skill("Go or Python", "Programming", SkillLevel.ADVANCED),
            Skill("Terraform/IaC", "Infrastructure", SkillLevel.ADVANCED),
            Skill("CI/CD Pipelines", "DevOps", SkillLevel.INTERMEDIATE),
            Skill("Linux/Networking", "Infrastructure", SkillLevel.INTERMEDIATE),
        ],
        nice_to_have=[
            "Operator/controller development experience",
            "Backstage plugin development",
            "Experience with Crossplane or similar",
        ],
    )
    
    PLATFORM_SRE = Role(
        title="Platform SRE",
        description="""
        Ensure platform reliability and performance. Define SLOs, manage
        incidents, and drive operational excellence.
        """,
        responsibilities=[
            "Define and track platform SLOs/SLIs",
            "Manage incidents and post-mortems",
            "Build observability and alerting",
            "Capacity planning and cost optimization",
            "On-call rotation lead",
            "Chaos engineering and resilience testing",
        ],
        required_skills=[
            Skill("Observability", "Operations", SkillLevel.EXPERT),
            Skill("Incident Management", "Operations", SkillLevel.ADVANCED),
            Skill("Kubernetes Operations", "Infrastructure", SkillLevel.ADVANCED),
            Skill("Performance Analysis", "Operations", SkillLevel.ADVANCED),
        ],
        nice_to_have=[
            "Prometheus/Grafana expertise",
            "Chaos engineering experience",
            "FinOps experience",
        ],
    )
    
    DEVELOPER_ADVOCATE = Role(
        title="Platform Developer Advocate",
        description="""
        Bridge between platform team and developer community. Drive adoption,
        gather feedback, and create content that helps developers succeed.
        """,
        responsibilities=[
            "Create tutorials, videos, and documentation",
            "Run office hours and workshops",
            "Gather and synthesize developer feedback",
            "Contribute to platform roadmap discussions",
            "Build community around the platform",
            "Evangelize golden paths and best practices",
        ],
        required_skills=[
            Skill("Technical Writing", "Communication", SkillLevel.EXPERT),
            Skill("Public Speaking", "Communication", SkillLevel.ADVANCED),
            Skill("Software Development", "Programming", SkillLevel.INTERMEDIATE),
            Skill("Community Building", "Soft Skills", SkillLevel.ADVANCED),
        ],
        nice_to_have=[
            "DevRel experience",
            "Content creation background",
            "Active in developer communities",
        ],
    )
    
    @classmethod
    def all_roles(cls) -> List[Role]:
        """Get all defined roles."""
        return [
            cls.PLATFORM_PRODUCT_MANAGER,
            cls.PLATFORM_TECH_LEAD,
            cls.PLATFORM_ENGINEER,
            cls.PLATFORM_SRE,
            cls.DEVELOPER_ADVOCATE,
        ]


@dataclass
class TeamMember:
    """A platform team member."""
    name: str
    role: Role
    skills: Dict[str, SkillLevel]
    
    def skill_gaps(self) -> List[Skill]:
        """Identify skills below required level."""
        gaps = []
        for required in self.role.required_skills:
            current = self.skills.get(required.name, SkillLevel.BASIC)
            if current.value < required.required_level.value:
                gaps.append(required)
        return gaps


class TeamCapacityPlanner:
    """Plan team capacity and identify gaps."""
    
    def __init__(self, members: List[TeamMember]):
        self.members = members
    
    def coverage_by_skill(self) -> Dict[str, int]:
        """Count team members with each skill at advanced+."""
        coverage = {}
        
        for member in self.members:
            for skill, level in member.skills.items():
                if level.value >= SkillLevel.ADVANCED.value:
                    coverage[skill] = coverage.get(skill, 0) + 1
        
        return coverage
    
    def single_points_of_failure(self) -> List[str]:
        """Identify skills with only one team member."""
        coverage = self.coverage_by_skill()
        return [skill for skill, count in coverage.items() if count == 1]
    
    def hiring_recommendations(self) -> List[str]:
        """Recommend roles to hire based on gaps."""
        recommendations = []
        spofs = self.single_points_of_failure()
        
        if spofs:
            recommendations.append(
                f"Consider hiring to reduce single points of failure: {', '.join(spofs)}"
            )
        
        # Check role coverage
        role_counts = {}
        for member in self.members:
            role_counts[member.role.title] = role_counts.get(member.role.title, 0) + 1
        
        if role_counts.get("Platform Engineer", 0) < 3:
            recommendations.append("Need more Platform Engineers for sustainable on-call")
        
        if "Platform Product Manager" not in role_counts:
            recommendations.append("Consider adding Platform Product Manager for strategic direction")
        
        return recommendations


# Example usage
team = [
    TeamMember(
        name="Alice",
        role=PlatformTeamRoles.PLATFORM_TECH_LEAD,
        skills={
            "Kubernetes": SkillLevel.EXPERT,
            "Go": SkillLevel.ADVANCED,
            "Terraform": SkillLevel.ADVANCED,
        },
    ),
    TeamMember(
        name="Bob",
        role=PlatformTeamRoles.PLATFORM_ENGINEER,
        skills={
            "Kubernetes": SkillLevel.ADVANCED,
            "Python": SkillLevel.ADVANCED,
            "CI/CD": SkillLevel.INTERMEDIATE,
        },
    ),
]

planner = TeamCapacityPlanner(team)
print("Single Points of Failure:", planner.single_points_of_failure())
print("Recommendations:", planner.hiring_recommendations())

---

📦 Platform as a Product

Product Mindset Principles

Platform Product Canvas

"""
Platform product management toolkit.
"""

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


class Priority(Enum):
    CRITICAL = "critical"
    HIGH = "high"
    MEDIUM = "medium"
    LOW = "low"


class FeatureStatus(Enum):
    BACKLOG = "backlog"
    PLANNED = "planned"
    IN_PROGRESS = "in_progress"
    BETA = "beta"
    GA = "ga"
    DEPRECATED = "deprecated"


@dataclass
class Persona:
    """Developer persona."""
    name: str
    role: str
    goals: List[str]
    pain_points: List[str]
    technical_level: str  # junior, mid, senior, staff
    primary_workflows: List[str]


@dataclass
class Feature:
    """Platform feature."""
    id: str
    name: str
    description: str
    status: FeatureStatus
    priority: Priority
    target_personas: List[str]
    success_metrics: List[str]
    dependencies: List[str] = field(default_factory=list)
    target_date: Optional[date] = None
    owner: Optional[str] = None


@dataclass
class Capability:
    """Platform capability grouping features."""
    name: str
    description: str
    features: List[Feature]
    sla: Optional[str] = None
    documentation_url: Optional[str] = None


@dataclass
class PlatformRoadmap:
    """Platform product roadmap."""
    capabilities: List[Capability]
    personas: List[Persona]
    vision: str
    
    def features_by_quarter(self, year: int, quarter: int) -> List[Feature]:
        """Get features planned for a quarter."""
        quarter_start = date(year, (quarter - 1) * 3 + 1, 1)
        quarter_end = date(year, quarter * 3, 28)  # Approximate
        
        features = []
        for capability in self.capabilities:
            for feature in capability.features:
                if feature.target_date:
                    if quarter_start <= feature.target_date <= quarter_end:
                        features.append(feature)
        
        return features
    
    def features_by_status(self, status: FeatureStatus) -> List[Feature]:
        """Get all features with a given status."""
        features = []
        for capability in self.capabilities:
            for feature in capability.features:
                if feature.status == status:
                    features.append(feature)
        return features
    
    def generate_roadmap_view(self) -> str:
        """Generate text roadmap view."""
        lines = [
            "Platform Roadmap",
            "=" * 50,
            "",
            f"Vision: {self.vision}",
            "",
        ]
        
        for capability in self.capabilities:
            lines.append(f"\n## {capability.name}")
            lines.append(f"{capability.description}")
            if capability.sla:
                lines.append(f"SLA: {capability.sla}")
            
            for feature in sorted(capability.features, key=lambda f: f.priority.value):
                status_emoji = {
                    FeatureStatus.GA: "✅",
                    FeatureStatus.BETA: "🔶",
                    FeatureStatus.IN_PROGRESS: "🔧",
                    FeatureStatus.PLANNED: "📋",
                    FeatureStatus.BACKLOG: "💭",
                    FeatureStatus.DEPRECATED: "⚠️",
                }
                lines.append(f"  {status_emoji[feature.status]} {feature.name} [{feature.status.value}]")
        
        return "\n".join(lines)


class PlatformProductManager:
    """Tools for platform product management."""
    
    def __init__(self, roadmap: PlatformRoadmap):
        self.roadmap = roadmap
    
    def prioritize_features(self, features: List[Feature]) -> List[Feature]:
        """Prioritize features using RICE scoring."""
        scored = []
        
        for feature in features:
            # Reach: How many developers affected
            reach = len(feature.target_personas) * 100
            
            # Impact: Based on priority
            impact_map = {
                Priority.CRITICAL: 3,
                Priority.HIGH: 2,
                Priority.MEDIUM: 1,
                Priority.LOW: 0.5,
            }
            impact = impact_map[feature.priority]
            
            # Confidence: Based on status
            confidence_map = {
                FeatureStatus.GA: 1.0,
                FeatureStatus.BETA: 0.8,
                FeatureStatus.IN_PROGRESS: 0.7,
                FeatureStatus.PLANNED: 0.5,
                FeatureStatus.BACKLOG: 0.3,
            }
            confidence = confidence_map.get(feature.status, 0.5)
            
            # Effort: Based on dependencies
            effort = 1 + len(feature.dependencies) * 0.5
            
            rice_score = (reach * impact * confidence) / effort
            scored.append((feature, rice_score))
        
        return [f for f, _ in sorted(scored, key=lambda x: x[1], reverse=True)]
    
    def identify_quick_wins(self) -> List[Feature]:
        """Identify high-impact, low-effort features."""
        quick_wins = []
        
        for capability in self.roadmap.capabilities:
            for feature in capability.features:
                if (
                    feature.priority in [Priority.HIGH, Priority.CRITICAL]
                    and len(feature.dependencies) == 0
                    and feature.status == FeatureStatus.BACKLOG
                ):
                    quick_wins.append(feature)
        
        return quick_wins
    
    def generate_release_notes(
        self,
        features: List[Feature],
        version: str,
    ) -> str:
        """Generate release notes for completed features."""
        lines = [
            f"# Platform Release {version}",
            f"Released: {date.today().isoformat()}",
            "",
            "## What's New",
        ]
        
        # Group by capability
        by_capability: Dict[str, List[Feature]] = {}
        for feature in features:
            for capability in self.roadmap.capabilities:
                if feature in capability.features:
                    if capability.name not in by_capability:
                        by_capability[capability.name] = []
                    by_capability[capability.name].append(feature)
                    break
        
        for capability, cap_features in by_capability.items():
            lines.append(f"\n### {capability}")
            for feature in cap_features:
                lines.append(f"- **{feature.name}**: {feature.description}")
        
        lines.extend([
            "",
            "## Migration Guide",
            "No breaking changes in this release.",
            "",
            "## Feedback",
            "Share feedback in #platform-feedback or during office hours.",
        ])
        
        return "\n".join(lines)


# Example usage
personas = [
    Persona(
        name="Backend Developer",
        role="Stream-aligned team developer",
        goals=["Deploy services quickly", "Debug production issues"],
        pain_points=["Complex Kubernetes YAML", "Slow CI pipelines"],
        technical_level="mid",
        primary_workflows=["Service deployment", "Database provisioning"],
    ),
]

roadmap = PlatformRoadmap(
    vision="Enable every developer to deploy with confidence in minutes, not days",
    personas=personas,
    capabilities=[
        Capability(
            name="Self-Service Infrastructure",
            description="Provision infrastructure without tickets",
            features=[
                Feature(
                    id="f1",
                    name="Database-as-a-Service",
                    description="Self-service PostgreSQL provisioning",
                    status=FeatureStatus.GA,
                    priority=Priority.HIGH,
                    target_personas=["Backend Developer"],
                    success_metrics=["Time to provision < 5min", "95% self-service"],
                ),
                Feature(
                    id="f2",
                    name="Redis Cache Service",
                    description="Self-service Redis provisioning",
                    status=FeatureStatus.PLANNED,
                    priority=Priority.MEDIUM,
                    target_personas=["Backend Developer"],
                    success_metrics=["Time to provision < 3min"],
                    target_date=date(2025, 3, 15),
                ),
            ],
        ),
    ],
)

pm = PlatformProductManager(roadmap)
print(roadmap.generate_roadmap_view())

---

🤝 Stakeholder Management

Stakeholder Map

Communication Strategy

"""
Stakeholder communication planning.
"""

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


class Influence(Enum):
    HIGH = "high"
    MEDIUM = "medium"
    LOW = "low"


class Interest(Enum):
    HIGH = "high"
    MEDIUM = "medium"
    LOW = "low"


class CommunicationType(Enum):
    WEEKLY_UPDATE = "weekly_update"
    MONTHLY_REVIEW = "monthly_review"
    QUARTERLY_ROADMAP = "quarterly_roadmap"
    AD_HOC = "ad_hoc"
    NEWSLETTER = "newsletter"


@dataclass
class Stakeholder:
    """A platform stakeholder."""
    name: str
    role: str
    group: str
    influence: Influence
    interest: Interest
    concerns: List[str]
    preferred_communication: CommunicationType


@dataclass
class CommunicationPlan:
    """Communication plan for stakeholders."""
    stakeholders: List[Stakeholder]
    
    def by_quadrant(self) -> Dict[str, List[Stakeholder]]:
        """Group stakeholders by influence/interest quadrant."""
        quadrants = {
            "manage_closely": [],  # High influence, high interest
            "keep_satisfied": [],  # High influence, low interest
            "keep_informed": [],   # Low influence, high interest
            "monitor": [],         # Low influence, low interest
        }
        
        for s in self.stakeholders:
            if s.influence == Influence.HIGH and s.interest == Interest.HIGH:
                quadrants["manage_closely"].append(s)
            elif s.influence == Influence.HIGH:
                quadrants["keep_satisfied"].append(s)
            elif s.interest == Interest.HIGH:
                quadrants["keep_informed"].append(s)
            else:
                quadrants["monitor"].append(s)
        
        return quadrants
    
    def generate_communication_schedule(self) -> str:
        """Generate recommended communication schedule."""
        quadrants = self.by_quadrant()
        
        lines = [
            "Platform Communication Schedule",
            "=" * 50,
            "",
            "## Weekly",
        ]
        
        for s in quadrants["manage_closely"]:
            lines.append(f"- 1:1 with {s.name} ({s.role})")
            lines.append(f"  Focus: {', '.join(s.concerns)}")
        
        lines.extend([
            "",
            "## Bi-Weekly",
        ])
        
        for s in quadrants["keep_informed"]:
            lines.append(f"- Update for {s.name}")
        
        lines.extend([
            "",
            "## Monthly",
        ])
        
        for s in quadrants["keep_satisfied"]:
            lines.append(f"- Review with {s.name}")
            lines.append(f"  Focus: {', '.join(s.concerns)}")
        
        lines.extend([
            "",
            "## Quarterly",
            "- All-hands platform update",
            "- Roadmap review with leadership",
            "- Developer satisfaction survey",
        ])
        
        return "\n".join(lines)


# Example
stakeholders = [
    Stakeholder(
        name="VP Engineering",
        role="Engineering Leadership",
        group="Leadership",
        influence=Influence.HIGH,
        interest=Interest.HIGH,
        concerns=["Developer productivity", "Time to market", "Cost efficiency"],
        preferred_communication=CommunicationType.WEEKLY_UPDATE,
    ),
    Stakeholder(
        name="Security Team",
        role="Security",
        group="Compliance",
        influence=Influence.HIGH,
        interest=Interest.MEDIUM,
        concerns=["Compliance", "Vulnerability management", "Access control"],
        preferred_communication=CommunicationType.MONTHLY_REVIEW,
    ),
    Stakeholder(
        name="Checkout Team",
        role="Stream-aligned Team",
        group="Product Teams",
        influence=Influence.LOW,
        interest=Interest.HIGH,
        concerns=["Self-service capabilities", "Fast deployments", "Clear docs"],
        preferred_communication=CommunicationType.NEWSLETTER,
    ),
]

plan = CommunicationPlan(stakeholders)
print(plan.generate_communication_schedule())

---

📈 Scaling the Platform Team

Growth Patterns

Scaling Checklist

"""
Platform team scaling readiness assessment.
"""

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


class ReadinessLevel(Enum):
    NOT_READY = "not_ready"
    PARTIALLY_READY = "partially_ready"
    READY = "ready"


@dataclass
class ScalingCriterion:
    """Criterion for scaling readiness."""
    name: str
    description: str
    check_function: str  # Describes what to check
    weight: float = 1.0


@dataclass
class Assessment:
    """Assessment result."""
    criterion: ScalingCriterion
    level: ReadinessLevel
    notes: str


class ScalingReadinessAssessment:
    """Assess platform team's readiness to scale."""
    
    STAGE_2_CRITERIA = [
        ScalingCriterion(
            "core_capabilities",
            "Core platform capabilities are stable and documented",
            "Check: <5% of changes break existing workflows",
        ),
        ScalingCriterion(
            "self_service",
            "Self-service covers 80%+ of common use cases",
            "Check: Ticket volume for covered use cases",
        ),
        ScalingCriterion(
            "on_call_sustainable",
            "On-call rotation is sustainable",
            "Check: <2 pages per on-call shift",
        ),
        ScalingCriterion(
            "documentation",
            "Documentation is comprehensive and maintained",
            "Check: Developer satisfaction with docs >70%",
        ),
        ScalingCriterion(
            "adoption",
            "Platform has adoption from multiple teams",
            "Check: >3 teams actively using platform",
        ),
    ]
    
    STAGE_3_CRITERIA = [
        ScalingCriterion(
            "product_manager",
            "Dedicated product manager in place",
            "Check: PM owns roadmap and stakeholder communication",
        ),
        ScalingCriterion(
            "api_stability",
            "Platform APIs are versioned and stable",
            "Check: Breaking changes require migration path",
        ),
        ScalingCriterion(
            "metrics_driven",
            "Team operates on metrics, not just feedback",
            "Check: DORA metrics tracked and improving",
        ),
        ScalingCriterion(
            "specialization",
            "Clear areas of specialization emerging",
            "Check: Can identify future sub-team boundaries",
        ),
        ScalingCriterion(
            "hiring_pipeline",
            "Established hiring pipeline",
            "Check: Can hire platform engineers within 3 months",
        ),
    ]
    
    def assess(self, stage: int, results: Dict[str, ReadinessLevel]) -> str:
        """Generate assessment report."""
        criteria = self.STAGE_2_CRITERIA if stage == 2 else self.STAGE_3_CRITERIA
        
        lines = [
            f"Platform Team Scaling Readiness - Stage {stage}",
            "=" * 50,
            "",
        ]
        
        ready_count = 0
        for criterion in criteria:
            level = results.get(criterion.name, ReadinessLevel.NOT_READY)
            emoji = {
                ReadinessLevel.READY: "✅",
                ReadinessLevel.PARTIALLY_READY: "🟡",
                ReadinessLevel.NOT_READY: "❌",
            }[level]
            
            if level == ReadinessLevel.READY:
                ready_count += 1
            
            lines.append(f"{emoji} {criterion.name}: {level.value}")
            lines.append(f"   {criterion.description}")
        
        total = len(criteria)
        percentage = (ready_count / total) * 100
        
        lines.extend([
            "",
            f"Overall: {ready_count}/{total} criteria met ({percentage:.0f}%)",
            "",
        ])
        
        if percentage >= 80:
            lines.append("✅ READY to scale to next stage")
        elif percentage >= 60:
            lines.append("🟡 ALMOST READY - address remaining gaps")
        else:
            lines.append("❌ NOT READY - focus on current stage")
        
        return "\n".join(lines)


# Example
assessment = ScalingReadinessAssessment()

# Stage 2 readiness check
results = {
    "core_capabilities": ReadinessLevel.READY,
    "self_service": ReadinessLevel.READY,
    "on_call_sustainable": ReadinessLevel.PARTIALLY_READY,
    "documentation": ReadinessLevel.PARTIALLY_READY,
    "adoption": ReadinessLevel.READY,
}

print(assessment.assess(2, results))

---

🌐 Platform Team Anti-Patterns

What to Avoid

Anti-Pattern	Description	Solution
Ivory Tower	Building without user input	Regular developer interviews
Ticket Queue	Becoming a support team	Invest in self-service
Not Invented Here	Rebuilding everything	Evaluate build vs buy
Big Bang	Large releases, long cycles	Iterative delivery
Platform Dictatorship	Forcing adoption	Make the right way the easy way
Boiling the Ocean	Trying to solve everything	Focus on highest impact

---

✅ Best Practices

Team Building

1. Hire for empathy - Customer-first mindset

2. Balance skills - Product + Engineering

3. Invest in enablement - Developers advocate

4. Sustainable on-call - Minimum 5 for healthy rotation

5. Career growth - Clear paths for platform engineers

Operating Model

1. Product mindset - Roadmaps, releases, customers

2. Measure outcomes - Not just activities

3. Communicate proactively - Newsletter, office hours

4. Iterate fast - Small, frequent improvements

5. Celebrate wins - Share success stories

---

🎯 Key Takeaways

Throughout this Platform Engineering 101 series, we've covered:

1. Platform engineering is about reducing cognitive load for developers

2. Internal Developer Platforms enable self-service at scale

3. Golden paths guide without restricting

4. Developer experience is the primary metric

5. Platform teams operate as product teams

6. Security and compliance are features, not constraints

7. Metrics and feedback drive continuous improvement

The journey to a mature platform takes time. Start small, iterate based on feedback, and always keep developer experience at the center of your decisions.

---

📚 References

• Team Topologies (Book)

• Platform Engineering Community

• CNCF Platforms White Paper

• The Twelve-Factor App

• Google SRE Books

• Backstage.io

• Humanitec Resources

---

Thank you for following the Platform Engineering 101 series. Happy platform building!