Postmortem: I Burned Out Leading a 20-Person Team at Meta: What I'd Do Differently

import os
import json
import logging
from datetime import datetime, timedelta
from typing import Dict, List, Optional
import requests
from requests.exceptions import RequestException

# Configure logging for audit trails
logging.basicConfig(
    level=logging.INFO,
    format="%(asctime)s - %(levelname)s - %(message)s",
    handlers=[logging.FileHandler("alert_fatigue.log"), logging.StreamHandler()]
)
logger = logging.getLogger(__name__)

class AlertFatigueAggregator:
    """Aggregates alert volume, priority, and lead notification metrics for burnout analysis."""

    def __init__(self, pagerduty_api_key: str, slack_api_key: str, lookback_days: int = 30):
        self.pagerduty_api_key = pagerduty_api_key
        self.slack_api_key = slack_api_key
        self.lookback_days = lookback_days
        self.base_pagerduty_url = "https://api.pagerduty.com"
        self.base_slack_url = "https://slack.com/api"
        self.metrics: Dict[str, any] = {
            "total_alerts": 0,
            "critical_alerts": 0,
            "non_critical_alerts": 0,
            "lead_notifications": 0,
            "avg_alerts_per_day": 0.0,
            "burnout_risk_score": 0.0
        }

    def _make_pagerduty_request(self, endpoint: str, params: Optional[Dict] = None) -> List[Dict]:
        """Make authenticated request to PagerDuty API with error handling."""
        headers = {
            "Authorization": f"Token {self.pagerduty_api_key}",
            "Accept": "application/vnd.pagerduty+json;version=2"
        }
        try:
            response = requests.get(
                f"{self.base_pagerduty_url}{endpoint}",
                headers=headers,
                params=params or {},
                timeout=10
            )
            response.raise_for_status()
            return response.json().get("incidents", [])
        except RequestException as e:
            logger.error(f"PagerDuty API request failed: {e}")
            return []
        except json.JSONDecodeError as e:
            logger.error(f"Failed to parse PagerDuty response: {e}")
            return []

    def fetch_incidents(self) -> List[Dict]:
        """Fetch incidents from PagerDuty within the lookback window."""
        since = (datetime.now() - timedelta(days=self.lookback_days)).isoformat()
        params = {
            "since": since,
            "until": datetime.now().isoformat(),
            "statuses[]": ["triggered", "acknowledged", "resolved"]
        }
        all_incidents = []
        offset = 0
        limit = 100
        while True:
            params["offset"] = offset
            params["limit"] = limit
            incidents = self._make_pagerduty_request("/incidents", params)
            if not incidents:
                break
            all_incidents.extend(incidents)
            offset += limit
            if len(incidents) < limit:
                break
        logger.info(f"Fetched {len(all_incidents)} total incidents from PagerDuty")
        return all_incidents

    def calculate_metrics(self, incidents: List[Dict]) -> None:
        """Calculate alert fatigue metrics from fetched incidents."""
        if not incidents:
            logger.warning("No incidents to calculate metrics from")
            return

        self.metrics["total_alerts"] = len(incidents)
        self.metrics["critical_alerts"] = sum(1 for i in incidents if i.get("urgency") == "high")
        self.metrics["non_critical_alerts"] = self.metrics["total_alerts"] - self.metrics["critical_alerts"]

        # Calculate lead notifications: assume 80% of non-critical alerts go to leads
        self.metrics["lead_notifications"] = int(self.metrics["non_critical_alerts"] * 0.8)
        self.metrics["avg_alerts_per_day"] = self.metrics["total_alerts"] / self.lookback_days

        # Burnout risk score: 0-100, where >70 is high risk
        # Formula: (avg_alerts_per_day * 2) + (lead_notifications / self.lookback_days * 0.5)
        self.metrics["burnout_risk_score"] = min(
            (self.metrics["avg_alerts_per_day"] * 2) + 
            (self.metrics["lead_notifications"] / self.lookback_days * 0.5),
            100.0
        )
        logger.info(f"Calculated burnout risk score: {self.metrics['burnout_risk_score']}")

    def export_metrics(self, output_path: str = "alert_fatigue_metrics.json") -> None:
        """Export metrics to JSON file for reporting."""
        try:
            with open(output_path, "w") as f:
                json.dump(self.metrics, f, indent=2)
            logger.info(f"Exported metrics to {output_path}")
        except IOError as e:
            logger.error(f"Failed to export metrics: {e}")

if __name__ == "__main__":
    # Load API keys from environment variables (never hardcode!)
    pagerduty_key = os.getenv("PAGERDUTY_API_KEY")
    slack_key = os.getenv("SLACK_API_KEY")

    if not pagerduty_key or not slack_key:
        logger.error("Missing required API keys in environment variables")
        exit(1)

    aggregator = AlertFatigueAggregator(
        pagerduty_api_key=pagerduty_key,
        slack_api_key=slack_key,
        lookback_days=30
    )

    incidents = aggregator.fetch_incidents()
    aggregator.calculate_metrics(incidents)
    aggregator.export_metrics()

    print(json.dumps(aggregator.metrics, indent=2))

import React, { useState, useEffect, useCallback } from "react";
import axios, { AxiosError } from "axios";
import { format, subDays } from "date-fns";

// Type definitions for async status entries
type StatusPriority = "blocked" | "at_risk" | "on_track" | "done";
type StatusEntry = {
  id: string;
  userId: string;
  userName: string;
  team: string;
  priority: StatusPriority;
  update: string;
  blockers: string[];
  timestamp: number;
  isRead: boolean;
};

type DashboardProps = {
  teamId: string;
  apiBaseUrl: string;
  leadId: string;
};

const AsyncStatusDashboard: React.FC = ({ teamId, apiBaseUrl, leadId }) => {
  const [statuses, setStatuses] = useState([]);
  const [loading, setLoading] = useState(true);
  const [error, setError] = useState(null);
  const [filter, setFilter] = useState("all");
  const [unreadCount, setUnreadCount] = useState(0);

  // Fetch status entries from internal API with error handling
  const fetchStatuses = useCallback(async () => {
    setLoading(true);
    setError(null);
    try {
      const response = await axios.get(
        `${apiBaseUrl}/teams/${teamId}/statuses`,
        {
          params: {
            since: subDays(new Date(), 1).toISOString(), // Last 24 hours
            limit: 100
          },
          headers: {
            "Authorization": `Bearer ${process.env.REACT_APP_API_KEY}`,
            "Content-Type": "application/json"
          },
          timeout: 5000
        }
      );
      setStatuses(response.data);
      // Calculate unread count for lead
      const unread = response.data.filter(s => s.isRead === false && s.priority === "blocked").length;
      setUnreadCount(unread);
    } catch (err) {
      const axiosError = err as AxiosError;
      if (axiosError.response) {
        setError(`API Error: ${axiosError.response.status} - ${axiosError.response.statusText}`);
      } else if (axiosError.request) {
        setError("No response received from status API");
      } else {
        setError(`Request failed: ${axiosError.message}`);
      }
      logger.error("Failed to fetch statuses:", err);
    } finally {
      setLoading(false);
    }
  }, [teamId, apiBaseUrl]);

  // Mark status as read when lead views it
  const markAsRead = useCallback(async (statusId: string) => {
    try {
      await axios.patch(
        `${apiBaseUrl}/statuses/${statusId}`,
        { isRead: true },
        {
          headers: { "Authorization": `Bearer ${process.env.REACT_APP_API_KEY}` },
          timeout: 3000
        }
      );
      setStatuses(prev => prev.map(s => s.id === statusId ? { ...s, isRead: true } : s));
      setUnreadCount(prev => Math.max(0, prev - 1));
    } catch (err) {
      logger.error(`Failed to mark status ${statusId} as read:`, err);
    }
  }, [apiBaseUrl]);

  // Filter statuses based on selected priority
  const filteredStatuses = filter === "all" 
    ? statuses 
    : statuses.filter(s => s.priority === filter);

  // Fetch statuses on mount and every 5 minutes
  useEffect(() => {
    fetchStatuses();
    const interval = setInterval(fetchStatuses, 5 * 60 * 1000);
    return () => clearInterval(interval);
  }, [fetchStatuses]);

  if (loading) return Loading team statuses...;
  if (error) return Error: {error};

  return (


        Async Team Status (Last 24h)

          {unreadCount} Unread Blocked Items


          Filter by priority:
           setFilter(e.target.value as StatusPriority | "all")}>
            All
            Blocked
            At Risk
            On Track
            Done




        {filteredStatuses.map(status => (
           !status.isRead && markAsRead(status.id)}
          >

              {status.userName}
              {status.team}
              {format(new Date(status.timestamp), "MMM d, h:mm a")}


              {status.update}
              {status.blockers.length > 0 && (

                  Blockers:

                    {status.blockers.map((blocker, idx) => (
                      {blocker}
                    ))}


              )}


        ))}


  );
};

export default AsyncStatusDashboard;

package main

import (
    "context"
    "encoding/json"
    "fmt"
    "log"
    "os"
    "time"

    "github.com/google/uuid"
    "golang.org/x/sync/errgroup"
)

// WorkloadItem represents a task assigned to a team lead
type WorkloadItem struct {
    ID          string    `json:"id"`
    Title       string    `json:"title"`
    AssigneeID  string    `json:"assignee_id"`
    AssigneeName string  `json:"assignee_name"`
    Priority    int       `json:"priority"` // 1 (low) to 5 (critical)
    EffortHours float64   `json:"effort_hours"`
    DueDate     time.Time `json:"due_date"`
    IsCompleted bool      `json:"is_completed"`
}

// Lead represents a team lead with current workload
type Lead struct {
    ID              string  `json:"id"`
    Name            string  `json:"name"`
    MaxWeeklyHours  float64 `json:"max_weekly_hours"` // Burnout threshold: 40h default
    CurrentHours    float64 `json:"current_hours"`
    WorkloadItems   []WorkloadItem `json:"workload_items"`
}

// WorkloadBalancer automates reallocation of tasks to prevent lead burnout
type WorkloadBalancer struct {
    Leads         []Lead  `json:"leads"`
    MaxLeadHours  float64 `json:"max_lead_hours"` // Hard cap: 50h/week
    ReallocationLog []string `json:"reallocation_log"`
}

// NewWorkloadBalancer initializes a balancer with lead data
func NewWorkloadBalancer(leads []Lead, maxLeadHours float64) *WorkloadBalancer {
    return &WorkloadBalancer{
        Leads:        leads,
        MaxLeadHours: maxLeadHours,
        ReallocationLog: []string{},
    }
}

// CalculateCurrentWorkloads sums effort hours for all leads
func (wb *WorkloadBalancer) CalculateCurrentWorkloads() error {
    for i := range wb.Leads {
        var total float64
        for _, item := range wb.Leads[i].WorkloadItems {
            if !item.IsCompleted {
                total += item.EffortHours
            }
        }
        wb.Leads[i].CurrentHours = total
        log.Printf("Lead %s (%s) current workload: %.2f hours", wb.Leads[i].ID, wb.Leads[i].Name, total)
        if total > wb.MaxLeadHours {
            log.Printf("WARNING: Lead %s exceeds max hours: %.2f > %.2f", wb.Leads[i].ID, total, wb.MaxLeadHours)
        }
    }
    return nil
}

// ReallocateOverloadedTasks moves tasks from overloaded leads to underloaded ones
func (wb *WorkloadBalancer) ReallocateOverloadedTasks(ctx context.Context) error {
    g, _ := errgroup.WithContext(ctx)

    for i := range wb.Leads {
        lead := &wb.Leads[i]
        if lead.CurrentHours <= wb.MaxLeadHours {
            continue // No reallocation needed
        }

        // Sort workload items by priority (lowest first to reallocate non-critical tasks)
        var overloadedItems []WorkloadItem
        for _, item := range lead.WorkloadItems {
            if !item.IsCompleted && item.Priority < 4 { // Don't reallocate critical (4+) tasks
                overloadedItems = append(overloadedItems, item)
            }
        }

        if len(overloadedItems) == 0 {
            wb.ReallocationLog = append(wb.ReallocationLog, fmt.Sprintf("Lead %s has no reallocatable tasks", lead.Name))
            continue
        }

        // Find underloaded lead to assign task to
        g.Go(func() error {
            for _, item := range overloadedItems {
                if lead.CurrentHours <= wb.MaxLeadHours {
                    break
                }
                targetLead := wb.findUnderloadedLead(lead.ID)
                if targetLead == nil {
                    wb.ReallocationLog = append(wb.ReallocationLog, fmt.Sprintf("No underloaded lead found for task %s", item.ID))
                    continue
                }

                // Reallocate task
                item.AssigneeID = targetLead.ID
                item.AssigneeName = targetLead.Name
                lead.CurrentHours -= item.EffortHours
                targetLead.CurrentHours += item.EffortHours

                // Update workload items for both leads
                lead.WorkloadItems = removeItemFromLead(lead.WorkloadItems, item.ID)
                targetLead.WorkloadItems = append(targetLead.WorkloadItems, item)

                wb.ReallocationLog = append(wb.ReallocationLog, fmt.Sprintf("Reallocated task %s from %s to %s", item.Title, lead.Name, targetLead.Name))
            }
            return nil
        })
    }

    return g.Wait()
}

// findUnderloadedLead finds a lead with current hours below max, excluding a given lead ID
func (wb *WorkloadBalancer) findUnderloadedLead(excludeLeadID string) *Lead {
    var underloaded *Lead
    minHours := wb.MaxLeadHours

    for i := range wb.Leads {
        l := &wb.Leads[i]
        if l.ID == excludeLeadID {
            continue
        }
        if l.CurrentHours < minHours {
            minHours = l.CurrentHours
            underloaded = l
        }
    }
    return underloaded
}

// removeItemFromLead removes a workload item by ID from a lead's list
func removeItemFromLead(items []WorkloadItem, itemID string) []WorkloadItem {
    result := []WorkloadItem{}
    for _, item := range items {
        if item.ID != itemID {
            result = append(result, item)
        }
    }
    return result
}

// ExportBalancedWorkloads writes the updated lead workloads to JSON
func (wb *WorkloadBalancer) ExportBalancedWorkloads(outputPath string) error {
    data, err := json.MarshalIndent(wb.Leads, "", "  ")
    if err != nil {
        return fmt.Errorf("failed to marshal lead data: %w", err)
    }

    err = os.WriteFile(outputPath, data, 0644)
    if err != nil {
        return fmt.Errorf("failed to write output file: %w", err)
    }
    log.Printf("Exported balanced workloads to %s", outputPath)
    return nil
}

func main() {
    // Sample lead data (in production, fetch from Asana/ Jira API)
    leads := []Lead{
        {
            ID: "lead-1", Name: "Alex", MaxWeeklyHours: 40, CurrentHours: 0,
            WorkloadItems: []WorkloadItem{
                {ID: uuid.New().String(), Title: "Q2 Roadmap Planning", AssigneeID: "lead-1", AssigneeName: "Alex", Priority: 3, EffortHours: 12, DueDate: time.Now().Add(7*24*time.Hour), IsCompleted: false},
                {ID: uuid.New().String(), Title: "Oncall Handoff", AssigneeID: "lead-1", AssigneeName: "Alex", Priority: 5, EffortHours: 8, DueDate: time.Now().Add(2*24*time.Hour), IsCompleted: false},
            },
        },
        {
            ID: "lead-2", Name: "Sam", MaxWeeklyHours: 40, CurrentHours: 0,
            WorkloadItems: []WorkloadItem{
                {ID: uuid.New().String(), Title: "Code Review Queue", AssigneeID: "lead-2", AssigneeName: "Sam", Priority: 2, EffortHours: 6, DueDate: time.Now().Add(3*24*time.Hour), IsCompleted: false},
            },
        },
    }

    balancer := NewWorkloadBalancer(leads, 50) // Hard cap 50h/week

    ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
    defer cancel()

    if err := balancer.CalculateCurrentWorkloads(); err != nil {
        log.Fatalf("Failed to calculate workloads: %v", err)
    }

    if err := balancer.ReallocateOverloadedTasks(ctx); err != nil {
        log.Fatalf("Failed to reallocate tasks: %v", err)
    }

    if err := balancer.ExportBalancedWorkloads("balanced_workloads.json"); err != nil {
        log.Fatalf("Failed to export workloads: %v", err)
    }

    // Print reallocation log
    fmt.Println("Reallocation Log:")
    for _, entry := range balancer.ReallocationLog {
        fmt.Println("-", entry)
    }
}

import requests

def create_async_status(api_key: str, team_id: str, update: str, priority: str, blockers: list):
    url = f"https://api.range.co/v1/teams/{team_id}/statuses"
    headers = {"Authorization": f"Bearer {api_key}"}
    payload = {
        "update": update,
        "priority": priority,
        "blockers": blockers,
        "timestamp": datetime.now().isoformat()
    }
    response = requests.post(url, json=payload, headers=headers)
    response.raise_for_status()
    return response.json()

import requests

def configure_alert_routing(api_key: str, service_id: str, critical_urgency: str = "high"):
    url = f"https://api.pagerduty.com/services/{service_id}/alert_routing"
    headers = {"Authorization": f"Token {api_key}"}
    payload = {
        "routing_rules": [
            {
                "condition": "urgency == high",
                "target": "lead_oncall"
            },
            {
                "condition": "urgency == low",
                "target": "shared_team_channel"
            }
        ]
    }
    response = requests.patch(url, json=payload, headers=headers)
    response.raise_for_status()
    return response.json()

import requests

def block_calendar_for_code_time(github_token: str, user_id: str, start_time: str, end_time: str):
    url = "https://api.github.com/user/calendar/events"
    headers = {"Authorization": f"token {github_token}"}
    payload = {
        "summary": "Lead Code Time (No Meetings)",
        "start": {"dateTime": start_time, "timeZone": "UTC"},
        "end": {"dateTime": end_time, "timeZone": "UTC"},
        "transparency": "opaque",
        "visibility": "private"
    }
    response = requests.post(url, json=payload, headers=headers)
    response.raise_for_status()
    return response.json()