Capstone - Complete Analytics System

# Python: Define analytics department structure
import pandas as pd
from dataclasses import dataclass
from typing import List, Dict
from enum import Enum

class DepartmentSize(Enum):
    STARTER = "Starter"
    GROWTH = "Growth"
    ENTERPRISE = "Enterprise"

@dataclass
class Role:
    """Analytics department role definition."""
    title: str
    reports_to: str
    primary_stakeholders: List[str]
    key_skills: List[str]
    min_experience_years: int
    salary_range: tuple  # (min, max) in thousands

# Define standard roles
ANALYTICS_ROLES = {
    "director": Role(
        title="Director of Analytics",
        reports_to="Technical Director / CEO",
        primary_stakeholders=["Board", "Technical Director", "Head Coach"],
        key_skills=["Leadership", "Strategy", "Communication", "Football Knowledge"],
        min_experience_years=8,
        salary_range=(120, 200)
    ),
    "head_performance": Role(
        title="Head of Performance Analytics",
        reports_to="Director of Analytics",
        primary_stakeholders=["First Team Coach", "Sports Science"],
        key_skills=["Sports Science", "Statistics", "Communication", "SQL"],
        min_experience_years=5,
        salary_range=(70, 100)
    ),
    "head_recruitment": Role(
        title="Head of Recruitment Analytics",
        reports_to="Director of Analytics",
        primary_stakeholders=["Director of Football", "Chief Scout"],
        key_skills=["Scouting", "Statistics", "Market Analysis", "Communication"],
        min_experience_years=5,
        salary_range=(70, 100)
    ),
    "data_engineer": Role(
        title="Data Engineer",
        reports_to="Director of Analytics",
        primary_stakeholders=["All Analytics Staff"],
        key_skills=["SQL", "Python", "Cloud (AWS/GCP)", "ETL", "APIs"],
        min_experience_years=3,
        salary_range=(60, 90)
    ),
    "senior_analyst": Role(
        title="Senior Data Analyst",
        reports_to="Head of Performance/Recruitment",
        primary_stakeholders=["Coaching Staff", "Scouts"],
        key_skills=["Statistics", "Python/R", "Visualization", "Football"],
        min_experience_years=3,
        salary_range=(50, 75)
    ),
    "analyst": Role(
        title="Data Analyst",
        reports_to="Senior Data Analyst",
        primary_stakeholders=["Coaching Staff", "Scouts"],
        key_skills=["Statistics", "Python/R", "Excel", "Visualization"],
        min_experience_years=1,
        salary_range=(35, 55)
    )
}

class DepartmentPlanner:
    """Plan analytics department structure based on budget."""

    def __init__(self, annual_budget: float):
        self.budget = annual_budget
        self.salary_budget = annual_budget * 0.70
        self.data_budget = annual_budget * 0.20
        self.tools_budget = annual_budget * 0.10

    def recommend_structure(self) -> Dict:
        """Recommend department structure based on budget."""
        avg_salary = 55000  # Average across all roles

        max_headcount = int(self.salary_budget / avg_salary)

        if max_headcount >= 8:
            size = DepartmentSize.ENTERPRISE
            recommended_roles = self._enterprise_structure()
        elif max_headcount >= 3:
            size = DepartmentSize.GROWTH
            recommended_roles = self._growth_structure()
        else:
            size = DepartmentSize.STARTER
            recommended_roles = self._starter_structure()

        return {
            "size": size.value,
            "max_headcount": max_headcount,
            "salary_budget": self.salary_budget,
            "data_budget": self.data_budget,
            "tools_budget": self.tools_budget,
            "recommended_roles": recommended_roles
        }

    def _starter_structure(self) -> List[str]:
        return ["Data Analyst (generalist)", "Part-time Video Analyst"]

    def _growth_structure(self) -> List[str]:
        return [
            "Head of Analytics",
            "Performance Analyst",
            "Recruitment Analyst",
            "Video Analyst"
        ]

    def _enterprise_structure(self) -> List[str]:
        return [
            "Director of Analytics",
            "Head of Performance Analytics",
            "Head of Recruitment Analytics",
            "Data Engineer",
            "Senior Data Analyst x2",
            "Data Analyst x2",
            "ML Engineer",
            "Video Analyst x2"
        ]

# Example
planner = DepartmentPlanner(400000)
structure = planner.recommend_structure()
print(f"Recommended: {structure['size']} ({structure['max_headcount']} staff)")

# Python: Role-based workflow assignment
import pandas as pd
from typing import Dict, List

# Define workflow ownership
workflows = pd.DataFrame({
    "workflow": [
        "Pre-match opposition report",
        "Post-match performance report",
        "Weekly recruitment shortlist",
        "Transfer window targets",
        "Injury risk dashboard",
        "Season review presentation",
        "Live match stats feed",
        "Player development reports"
    ],
    "primary_owner": [
        "Performance Analyst",
        "Performance Analyst",
        "Recruitment Analyst",
        "Recruitment Analyst",
        "Performance Analyst",
        "Head of Analytics",
        "Data Engineer",
        "Performance Analyst"
    ],
    "stakeholders": [
        "First Team Coach",
        "First Team Coach, Players",
        "Chief Scout, DoF",
        "DoF, Board",
        "Sports Science, Medical",
        "Board, Technical Director",
        "Coaching Staff",
        "Academy Director"
    ],
    "frequency": [
        "Per match (MD-2)",
        "Per match (MD+1)",
        "Weekly",
        "Window periods",
        "Daily",
        "Annual",
        "Real-time",
        "Monthly"
    ],
    "estimated_hours": [4, 3, 8, 20, 1, 40, 2, 6]
})

# Calculate workload
workload = workflows.groupby("primary_owner").agg({
    "workflow": "count",
    "estimated_hours": "sum"
}).reset_index()
workload.columns = ["role", "workflow_count", "total_hours"]

print("Workflow ownership by role:")
print(workload)

# Python: Technology stack cost calculator
import pandas as pd
from typing import Dict, List

# Define tool costs
tool_costs = pd.DataFrame({
    "category": [
        "Data Provider", "Data Provider", "Data Provider",
        "Cloud", "Cloud",
        "Visualization", "Visualization",
        "Video", "Video",
        "Collaboration"
    ],
    "tool": [
        "StatsBomb", "Opta", "Wyscout",
        "AWS Basic", "AWS Enterprise",
        "Tableau", "Power BI",
        "Hudl", "Sportscode",
        "Notion/Confluence"
    ],
    "annual_cost": [
        50000, 100000, 30000,
        6000, 50000,
        15000, 10000,
        10000, 25000,
        2000
    ],
    "tier": [
        "Growth", "Enterprise", "Starter",
        "Growth", "Enterprise",
        "Growth", "Starter",
        "Starter", "Growth",
        "Starter"
    ]
})

def calculate_stack_cost(tier: str) -> Dict:
    """Calculate technology stack cost for a tier."""
    # Filter to tier and starter (baseline)
    available = tool_costs[
        (tool_costs["tier"] == tier) | (tool_costs["tier"] == "Starter")
    ]

    # Take cheapest per category
    selected = available.loc[
        available.groupby("category")["annual_cost"].idxmin()
    ]

    return {
        "tier": tier,
        "total_cost": selected["annual_cost"].sum(),
        "tools": selected["tool"].tolist(),
        "breakdown": selected[["category", "tool", "annual_cost"]].to_dict("records")
    }

# Compare tiers
for tier in ["Starter", "Growth", "Enterprise"]:
    result = calculate_stack_cost(tier)
    print(f"{tier}: €{result['total_cost']:,} ({len(result['tools'])} tools)")

# Python: Stakeholder engagement framework
import pandas as pd
from dataclasses import dataclass
from typing import List, Dict

@dataclass
class Stakeholder:
    """Football operations stakeholder profile."""
    name: str
    role: str
    primary_needs: List[str]
    preferred_format: str
    meeting_frequency: str
    trust_building_tips: List[str]

# Define key stakeholders
STAKEHOLDERS = {
    "head_coach": Stakeholder(
        name="Head Coach",
        role="First Team Manager",
        primary_needs=[
            "Opposition analysis",
            "Player performance insights",
            "Set piece analysis",
            "Quick pre-match summaries"
        ],
        preferred_format="Brief presentations, 1-page visual summaries",
        meeting_frequency="Daily during season",
        trust_building_tips=[
            "Deliver quick wins early",
            "Respect their experience",
            "Never contradict in public",
            "Be available on match days"
        ]
    ),
    "dof": Stakeholder(
        name="Director of Football",
        role="Technical Director",
        primary_needs=[
            "Transfer targets with data backing",
            "Squad planning analysis",
            "Contract situation overview",
            "Competitor intelligence"
        ],
        preferred_format="Detailed reports, spreadsheets, presentations",
        meeting_frequency="Weekly",
        trust_building_tips=[
            "Provide market context",
            "Track recommendation success",
            "Be honest about uncertainty",
            "Support negotiation with data"
        ]
    ),
    "scouts": Stakeholder(
        name="Scouting Team",
        role="Chief Scout + Scouts",
        primary_needs=[
            "Player identification filters",
            "Comparison tools",
            "League-adjusted metrics",
            "Video integration"
        ],
        preferred_format="Interactive tools, player profiles",
        meeting_frequency="2x weekly",
        trust_building_tips=[
            "Position as a complement, not replacement",
            "Celebrate when scouts find gems data missed",
            "Learn from their expertise",
            "Make their workflow easier"
        ]
    )
}

class StakeholderEngagement:
    """Manage stakeholder relationships and deliverables."""

    def __init__(self):
        self.stakeholders = STAKEHOLDERS
        self.engagement_log = []

    def get_weekly_deliverables(self) -> Dict[str, List[str]]:
        """Get weekly deliverables by stakeholder."""
        return {
            "Head Coach": [
                "Pre-match opposition report (MD-2)",
                "Post-match performance summary (MD+1)",
                "Set piece update if applicable"
            ],
            "Director of Football": [
                "Weekly recruitment shortlist update",
                "Market movement summary",
                "Contract situation flags"
            ],
            "Scouting Team": [
                "New player alerts matching profiles",
                "Video clips for top targets",
                "League adjustment updates"
            ],
            "Sports Science": [
                "Daily load monitoring dashboard",
                "Weekly injury risk report",
                "Return-to-play tracking"
            ]
        }

    def measure_engagement(self) -> Dict[str, str]:
        """Define engagement success metrics."""
        return {
            "Report adoption": "Target >80% opened/used",
            "Meeting attendance": "Target >90%",
            "Ad-hoc requests": "Target >5/week (indicates value)",
            "Decisions influenced": "Track recommendations adopted",
            "Satisfaction score": "Quarterly survey, target >4/5"
        }

engagement = StakeholderEngagement()
print("Weekly deliverables:")
for stakeholder, deliverables in engagement.get_weekly_deliverables().items():
    print(f"\n{stakeholder}:")
    for d in deliverables:
        print(f"  - {d}")