Retrospective: 3 Years of Using Remote Work: Why We Mandated 2 Days in Office in 2026

import os\nimport json\nimport pandas as pd\nfrom slack_sdk import WebClient\nfrom slack_sdk.errors import SlackApiError\nfrom datetime import datetime, timedelta\nimport logging\n\n# Configure logging for audit trails\nlogging.basicConfig(\n    level=logging.INFO,\n    format=\"%(asctime)s - %(levelname)s - %(message)s\",\n    handlers=[logging.FileHandler(\"collab_metrics.log\"), logging.StreamHandler()]\n)\n\nclass CollaborationAnalyzer:\n    \"\"\"Analyzes Slack workspace data to measure cross-team collaboration velocity for remote/hybrid teams.\"\"\"\n    \n    def __init__(self, slack_token: str, channel_ids: list[str]):\n        self.client = WebClient(token=slack_token)\n        self.channel_ids = channel_ids\n        self.team_mapping = {\n            \"backend\": [\"U123456\", \"U789012\", \"U345678\"],  # Replace with actual user IDs\n            \"frontend\": [\"U901234\", \"U567890\", \"U123098\"],\n            \"devops\": [\"U456789\", \"U012345\"]\n        }\n        self.metrics = pd.DataFrame(columns=[\"timestamp\", \"sender_team\", \"mentioned_teams\", \"thread_depth\"])\n\n    def fetch_channel_history(self, channel_id: str, days_back: int = 90) -> list[dict]:\n        \"\"\"Fetch last 90 days of messages for a given Slack channel with pagination handling.\"\"\"\n        messages = []\n        cursor = None\n        oldest = datetime.now() - timedelta(days=days_back)\n        oldest_ts = oldest.timestamp()\n        \n        try:\n            while True:\n                response = self.client.conversations_history(\n                    channel=channel_id,\n                    oldest=oldest_ts,\n                    cursor=cursor,\n                    limit=200\n                )\n                messages.extend(response[\"messages\"])\n                if not response[\"has_more\"]:\n                    break\n                cursor = response[\"response_metadata\"][\"next_cursor\"]\n            logging.info(f\"Fetched {len(messages)} messages from channel {channel_id}\")\n            return messages\n        except SlackApiError as e:\n            logging.error(f\"Slack API error fetching channel {channel_id}: {e.response['error']}\")\n            return []\n        except Exception as e:\n            logging.error(f\"Unexpected error fetching channel {channel_id}: {str(e)}\")\n            return []\n\n    def classify_user_team(self, user_id: str) -> str:\n        \"\"\"Map Slack user ID to team name, return 'unknown' if not found.\"\"\"\n        for team, user_ids in self.team_mapping.items():\n            if user_id in user_ids:\n                return team\n        return \"unknown\"\n\n    def process_messages(self, messages: list[dict]):\n        \"\"\"Process raw messages to extract collaboration metrics.\"\"\"\n        for msg in messages:\n            # Skip bots and system messages\n            if msg.get(\"subtype\") in [\"bot_message\", \"channel_join\", \"channel_leave\"]:\n                continue\n            \n            sender_id = msg.get(\"user\")\n            if not sender_id:\n                continue\n            \n            sender_team = self.classify_user_team(sender_id)\n            mentioned_users = []\n            \n            # Extract user mentions from message text\n            if \"user_ids\" in msg.get(\"blocks\", [{}])[0].get(\"elements\", [{}])[0]:\n                mentioned_users = msg[\"blocks\"][0][\"elements\"][0].get(\"user_ids\", [])\n            # Fallback to regex for legacy messages\n            elif \"text\" in msg:\n                import re\n                mentioned_users = re.findall(r\"<@(U\\w+)>", msg[\"text\"])\n            \n            mentioned_teams = set()\n            for user_id in mentioned_users:\n                team = self.classify_user_team(user_id)\n                if team != \"unknown\":\n                    mentioned_teams.add(team)\n            \n            # Calculate thread depth if message is in a thread\n            thread_depth = 0\n            if \"thread_ts\" in msg:\n                thread_depth = len([m for m in messages if m.get(\"thread_ts\") == msg[\"thread_ts\"]])\n            \n            self.metrics = pd.concat([\n                self.metrics,\n                pd.DataFrame([{\n                    \"timestamp\": datetime.fromtimestamp(float(msg[\"ts\"])),\n                    \"sender_team\": sender_team,\n                    \"mentioned_teams\": list(mentioned_teams - {sender_team}),\n                    \"thread_depth\": thread_depth\n                }])\n            ], ignore_index=True)\n\n    def generate_report(self) -> dict:\n        \"\"\"Generate collaboration velocity report with cross-team metrics.\"\"\"\n        if self.metrics.empty:\n            return {\"error\": \"No metrics data available\"}\n        \n        # Calculate cross-team mention rate\n        cross_team_mentions = self.metrics[self.metrics[\"mentioned_teams\"].apply(len) > 0]\n        cross_team_rate = len(cross_team_mentions) / len(self.metrics) * 100\n        \n        # Calculate average thread depth for cross-team conversations\n        avg_thread_depth = cross_team_mentions[\"thread_depth\"].mean() if not cross_team_mentions.empty else 0\n        \n        # Calculate per-team collaboration scores\n        team_scores = {}\n        for team in self.team_mapping.keys():\n            team_msgs = self.metrics[self.metrics[\"sender_team\"] == team]\n            team_cross = team_msgs[team_msgs[\"mentioned_teams\"].apply(len) > 0]\n            team_scores[team] = {\n                \"total_messages\": len(team_msgs),\n                \"cross_team_messages\": len(team_cross),\n                \"cross_team_rate\": len(team_cross) / len(team_msgs) * 100 if len(team_msgs) > 0 else 0\n            }\n        \n        return {\n            \"total_messages_analyzed\": len(self.metrics),\n            \"overall_cross_team_mention_rate\": round(cross_team_rate, 2),\n            \"avg_cross_team_thread_depth\": round(avg_thread_depth, 2),\n            \"per_team_scores\": team_scores,\n            \"analysis_period_days\": 90\n        }\n\nif __name__ == \"__main__\":\n    # Load Slack token from environment variable (never hardcode!)\n    slack_token = os.environ.get(\"SLACK_BOT_TOKEN\")\n    if not slack_token:\n        logging.error(\"SLACK_BOT_TOKEN environment variable not set\")\n        exit(1)\n    \n    # List of public channels to analyze (replace with actual channel IDs)\n    channels_to_analyze = [\"C123456\", \"C789012\", \"C345678\"]\n    \n    analyzer = CollaborationAnalyzer(slack_token, channels_to_analyze)\n    \n    for channel_id in channels_to_analyze:\n        messages = analyzer.fetch_channel_history(channel_id)\n        analyzer.process_messages(messages)\n    \n    report = analyzer.generate_report()\n    \n    # Save report to JSON file\n    with open(f\"collab_report_{datetime.now().strftime('%Y%m%d')}.json\", \"w\") as f:\n        json.dump(report, f, indent=2)\n    \n    logging.info(f\"Collaboration report generated: {json.dumps(report, indent=2)}\")

// Rust 1.82 PR Review Cycle Time Analyzer\n// Analyzes GitHub PR data to compare review times between fully remote (2023-2025) and hybrid (2026+) periods\n// Uses octocrab 0.35.0 for GitHub API integration\n\nuse octocrab::Octocrab;\nuse octocrab::models::pulls::PullRequest;\nuse chrono::{DateTime, Utc, Duration};\nuse std::collections::HashMap;\nuse std::env;\nuse std::error::Error;\nuse tokio;\n\n// Define date ranges for analysis\nconst REMOTE_START: &str = \"2023-01-01T00:00:00Z\";\nconst REMOTE_END: &str = \"2025-12-31T23:59:59Z\";\nconst HYBRID_START: &str = \"2026-01-01T00:00:00Z\";\nconst HYBRID_END: &str = \"2026-12-31T23:59:59Z\";\n\n#[derive(Debug, Clone)]\nstruct ReviewMetrics {\n    pr_count: u32,\n    total_review_hours: f64,\n    avg_review_hours: f64,\n    median_review_hours: f64,\n    p99_review_hours: f64,\n}\n\nimpl ReviewMetrics {\n    fn new() -> Self {\n        ReviewMetrics {\n            pr_count: 0,\n            total_review_hours: 0.0,\n            avg_review_hours: 0.0,\n            median_review_hours: 0.0,\n            p99_review_hours: 0.0,\n        }\n    }\n\n    fn calculate_median(review_times: &mut Vec) -> f64 {\n        review_times.sort_by(|a, b| a.partial_cmp(b).unwrap());\n        let len = review_times.len();\n        if len == 0 {\n            return 0.0;\n        }\n        if len % 2 == 0 {\n            (review_times[len/2 - 1] + review_times[len/2]) / 2.0\n        } else {\n            review_times[len/2]\n        }\n    }\n\n    fn calculate_p99(review_times: &Vec) -> f64 {\n        if review_times.is_empty() {\n            return 0.0;\n        }\n        let mut sorted = review_times.clone();\n        sorted.sort_by(|a, b| a.partial_cmp(b).unwrap());\n        let idx = (sorted.len() as f64 * 0.99).ceil() as usize;\n        sorted[idx.min(sorted.len() - 1)]\n    }\n}\n\nasync fn fetch_prs(\n    octocrab: &Octocrab,\n    owner: &str,\n    repo: &str,\n    start_date: DateTime,\n    end_date: DateTime\n) -> Result, Box> {\n    let mut prs = Vec::new();\n    let mut page = 1u32;\n    \n    loop {\n        let response = octocrab\n            .pulls(owner, repo)\n            .list()\n            .state(octocrab::params::State::All)\n            .per_page(100)\n            .page(page)\n            .send()\n            .await?;\n        \n        for pr in response.items() {\n            // Parse PR creation date\n            let pr_created: DateTime = pr.created_at.unwrap_or_default();\n            if pr_created < start_date {\n                // PRs are sorted by creation date descending, so break if we go past start date\n                break;\n            }\n            if pr_created > end_date {\n                continue;\n            }\n            prs.push(pr.clone());\n        }\n        \n        if response.next_page().is_none() {\n            break;\n        }\n        page += 1;\n    }\n    \n    Ok(prs)\n}\n\nfn calculate_review_time(pr: &PullRequest) -> Option {\n    let created = pr.created_at?;\n    let merged = pr.merged_at?;\n    let duration = merged.signed_duration_since(created);\n    Some(duration.num_minutes() as f64 / 60.0) // Convert to hours\n}\n\nasync fn analyze_period(\n    octocrab: &Octocrab,\n    owner: &str,\n    repo: &str,\n    start: DateTime,\n    end: DateTime\n) -> Result> {\n    let prs = fetch_prs(octocrab, owner, repo, start, end).await?;\n    let mut metrics = ReviewMetrics::new();\n    let mut review_times = Vec::new();\n    \n    for pr in prs {\n        if let Some(review_hours) = calculate_review_time(&pr) {\n            metrics.total_review_hours += review_hours;\n            review_times.push(review_hours);\n        }\n    }\n    \n    metrics.pr_count = review_times.len() as u32;\n    if metrics.pr_count > 0 {\n        metrics.avg_review_hours = metrics.total_review_hours / metrics.pr_count as f64;\n        metrics.median_review_hours = ReviewMetrics::calculate_median(&mut review_times);\n        metrics.p99_review_hours = ReviewMetrics::calculate_p99(&review_times);\n    }\n    \n    Ok(metrics)\n}\n\n#[tokio::main]\nasync fn main() -> Result<(), Box> {\n    // Load GitHub token from environment variable\n    let github_token = env::var(\"GITHUB_TOKEN\").expect(\"GITHUB_TOKEN environment variable must be set\");\n    \n    // Initialize Octocrab client\n    let octocrab = Octocrab::builder()\n        .personal_token(github_token)\n        .build()?;\n    \n    // Repository to analyze (replace with your org/repo)\n    let owner = \"my-engineering-org\";\n    let repo = \"core-services\";\n    \n    // Parse date strings to DateTime\n    let remote_start = DateTime::parse_from_rfc3339(REMOTE_START)?.with_timezone(&Utc);\n    let remote_end = DateTime::parse_from_rfc3339(REMOTE_END)?.with_timezone(&Utc);\n    let hybrid_start = DateTime::parse_from_rfc3339(HYBRID_START)?.with_timezone(&Utc);\n    let hybrid_end = DateTime::parse_from_rfc3339(HYBRID_END)?.with_timezone(&Utc);\n    \n    // Analyze fully remote period\n    println!(\"Analyzing fully remote period (2023-2025)...\");\n    let remote_metrics = analyze_period(&octocrab, owner, repo, remote_start, remote_end).await?;\n    \n    // Analyze hybrid period\n    println!(\"Analyzing hybrid period (2026)...\");\n    let hybrid_metrics = analyze_period(&octocrab, owner, repo, hybrid_start, hybrid_end).await?;\n    \n    // Print comparison report\n    println!(\"\\n=== PR Review Cycle Time Comparison ===\");\n    println!(\"Fully Remote (2023-2025):\");\n    println!(\"  PR Count: {}\", remote_metrics.pr_count);\n    println!(\"  Avg Review Time: {:.2} hours\", remote_metrics.avg_review_hours);\n    println!(\"  Median Review Time: {:.2} hours\", remote_metrics.median_review_hours);\n    println!(\"  P99 Review Time: {:.2} hours\", remote_metrics.p99_review_hours);\n    \n    println!(\"\\nHybrid (2026):\");\n    println!(\"  PR Count: {}\", hybrid_metrics.pr_count);\n    println!(\"  Avg Review Time: {:.2} hours\", hybrid_metrics.avg_review_hours);\n    println!(\"  Median Review Time: {:.2} hours\", hybrid_metrics.median_review_hours);\n    println!(\"  P99 Review Time: {:.2} hours\", hybrid_metrics.p99_review_hours);\n    \n    // Calculate improvement percentage\n    if remote_metrics.avg_review_hours > 0.0 {\n        let improvement = (remote_metrics.avg_review_hours - hybrid_metrics.avg_review_hours) / remote_metrics.avg_review_hours * 100.0;\n        println!(\"\\nAvg review time improvement: {:.2}%\", improvement);\n    }\n    \n    Ok(())\n}

// TypeScript 5.6 Turnover Cost Calculator\n// Calculates ROI of hybrid office mandate by comparing remote vs hybrid period turnover costs\n// Uses real 2023-2026 HR data from our organization\n\nimport fs from 'fs/promises';\nimport path from 'path';\n\ntype EmployeeRecord = {\n    id: string;\n    team: 'backend' | 'frontend' | 'devops' | 'product';\n    startDate: Date;\n    endDate?: Date;\n    terminationReason?: 'voluntary' | 'involuntary' | 'layoff';\n    level: 1 | 2 | 3 | 4 | 5; // 1: junior, 5: principal\n};\n\ntype CostConfig = {\n    rehireCostPerLevel: Record; // Cost to rehire per level (recruiter fees, onboarding)\n    lostProductivityPerLevel: Record; // Monthly lost productivity per level\n    officeCostPerEmployeePerMonth: number; // Desk, utilities, coffee, etc.\n    fullyRemotePeriod: { start: Date; end: Date };\n    hybridPeriod: { start: Date; end: Date };\n};\n\ntype TurnoverReport = {\n    period: string;\n    totalEmployees: number;\n    terminatedEmployees: number;\n    turnoverRate: number;\n    totalTurnoverCost: number;\n    totalOfficeCost: number;\n    netSavings: number;\n};\n\nconst DEFAULT_CONFIG: CostConfig = {\n    rehireCostPerLevel: {\n        1: 25000, // Junior: 2 months salary + recruiter fee\n        2: 35000,\n        3: 55000,\n        4: 85000,\n        5: 150000\n    },\n    lostProductivityPerLevel: {\n        1: 8000, // Junior: ~1 month salary\n        2: 12000,\n        3: 20000,\n        4: 32000,\n        5: 60000\n    },\n    officeCostPerEmployeePerMonth: 18,\n    fullyRemotePeriod: {\n        start: new Date('2023-01-01'),\n        end: new Date('2025-12-31')\n    },\n    hybridPeriod: {\n        start: new Date('2026-01-01'),\n        end: new Date('2026-12-31')\n    }\n};\n\nclass TurnoverAnalyzer {\n    private employeeRecords: EmployeeRecord[] = [];\n    private config: CostConfig;\n\n    constructor(config: CostConfig = DEFAULT_CONFIG) {\n        this.config = config;\n    }\n\n    async loadEmployeeData(filePath: string): Promise {\n        try {\n            const rawData = await fs.readFile(filePath, 'utf-8');\n            const parsed = JSON.parse(rawData) as EmployeeRecord[];\n            \n            // Validate and convert date strings to Date objects\n            this.employeeRecords = parsed.map(record => ({\n                ...record,\n                startDate: new Date(record.startDate),\n                endDate: record.endDate ? new Date(record.endDate) : undefined\n            }));\n            \n            console.log(`Loaded ${this.employeeRecords.length} employee records`);\n        } catch (error) {\n            console.error(`Failed to load employee data from ${filePath}:`, error);\n            throw new Error(`Employee data load failed: ${error}`);\n        }\n    }\n\n    private isInPeriod(employee: EmployeeRecord, period: { start: Date; end: Date }): boolean {\n        // Employee was active at any point during the period\n        if (employee.endDate) {\n            return employee.startDate <= period.end && employee.endDate >= period.start;\n        }\n        return employee.startDate <= period.end;\n    }\n\n    private getTerminatedInPeriod(period: { start: Date; end: Date }): EmployeeRecord[] {\n        return this.employeeRecords.filter(emp => {\n            return emp.terminationReason === 'voluntary' && \n                   emp.endDate &&\n                   emp.endDate >= period.start && \n                   emp.endDate <= period.end;\n        });\n    }\n\n    private calculatePeriodCosts(\n        period: { start: Date; end: Date },\n        periodName: string\n    ): TurnoverReport {\n        const activeEmployees = this.employeeRecords.filter(emp => this.isInPeriod(emp, period));\n        const terminated = this.getTerminatedInPeriod(period);\n        const monthsInPeriod = (period.end.getTime() - period.start.getTime()) / (1000 * 60 * 60 * 24 * 30.44);\n        \n        // Calculate turnover rate\n        const turnoverRate = activeEmployees.length > 0 \n            ? (terminated.length / activeEmployees.length) * 100 \n            : 0;\n        \n        // Calculate total turnover cost\n        let totalTurnoverCost = 0;\n        for (const emp of terminated) {\n            const rehireCost = this.config.rehireCostPerLevel[emp.level] || 0;\n            const lostProductivity = this.config.lostProductivityPerLevel[emp.level] || 0;\n            totalTurnoverCost += rehireCost + lostProductivity;\n        }\n        \n        // Calculate office costs (only for hybrid period, remote had 0)\n        const isHybrid = periodName === 'Hybrid (2026)';\n        const totalOfficeCost = isHybrid \n            ? this.config.officeCostPerEmployeePerMonth * activeEmployees.length * monthsInPeriod \n            : 0;\n        \n        // Calculate net savings (remote turnover cost - (hybrid turnover cost + office cost))\n        const netSavings = 0; // Calculated later in comparison\n        \n        return {\n            period: periodName,\n            totalEmployees: activeEmployees.length,\n            terminatedEmployees: terminated.length,\n            turnoverRate: parseFloat(turnoverRate.toFixed(2)),\n            totalTurnoverCost: parseFloat(totalTurnoverCost.toFixed(2)),\n            totalOfficeCost: parseFloat(totalOfficeCost.toFixed(2)),\n            netSavings: 0\n        };\n    }\n\n    generateComparisonReport(): { remote: TurnoverReport; hybrid: TurnoverReport; netSavings: number } {\n        const remoteReport = this.calculatePeriodCosts(\n            this.config.fullyRemotePeriod,\n            'Fully Remote (2023-2025)'\n        );\n        \n        const hybridReport = this.calculatePeriodCosts(\n            this.config.hybridPeriod,\n            'Hybrid (2026)'\n        );\n        \n        // Calculate net savings: (remote turnover cost * 12/36 months) - (hybrid turnover cost + hybrid office cost)\n        // Normalize remote cost to 12 months to match hybrid period length\n        const normalizedRemoteCost = remoteReport.totalTurnoverCost * (12 / 36);\n        const hybridTotalCost = hybridReport.totalTurnoverCost + hybridReport.totalOfficeCost;\n        const netSavings = normalizedRemoteCost - hybridTotalCost;\n        \n        remoteReport.netSavings = 0;\n        hybridReport.netSavings = parseFloat(netSavings.toFixed(2));\n        \n        return {\n            remote: remoteReport,\n            hybrid: hybridReport,\n            netSavings: parseFloat(netSavings.toFixed(2))\n        };\n    }\n}\n\nasync function main() {\n    try {\n        const analyzer = new TurnoverAnalyzer();\n        \n        // Load employee data from JSON file (replace with actual path)\n        await analyzer.loadEmployeeData(path.join(__dirname, 'employee_data.json'));\n        \n        const report = analyzer.generateComparisonReport();\n        \n        console.log('\\n=== Turnover Cost Comparison: Remote vs Hybrid ===');\n        console.log('\\nFully Remote (2023-2025, normalized to 12 months):');\n        console.log(`  Total Employees: ${report.remote.totalEmployees}`);\n        console.log(`  Terminated Employees: ${report.remote.terminatedEmployees}`);\n        console.log(`  Turnover Rate: ${report.remote.turnoverRate}%`);\n        console.log(`  Total Turnover Cost: $${report.remote.totalTurnoverCost.toLocaleString()}`);\n        \n        console.log('\\nHybrid (2026):');\n        console.log(`  Total Employees: ${report.hybrid.totalEmployees}`);\n        console.log(`  Terminated Employees: ${report.hybrid.terminatedEmployees}`);\n        console.log(`  Turnover Rate: ${report.hybrid.turnoverRate}%`);\n        console.log(`  Total Turnover Cost: $${report.hybrid.totalTurnoverCost.toLocaleString()}`);\n        console.log(`  Total Office Cost: $${report.hybrid.totalOfficeCost.toLocaleString()}`);\n        \n        console.log(`\\nNet Savings with Hybrid Mandate: $${report.netSavings.toLocaleString()}`);\n        console.log(`(Positive = Hybrid saved money, Negative = Remote was cheaper)`);\n        \n        // Save report to JSON\n        await fs.writeFile(\n            path.join(__dirname, `turnover_report_${new Date().toISOString().split('T')[0]}.json`),\n            JSON.stringify(report, null, 2)\n        );\n        \n    } catch (error) {\n        console.error('Failed to generate turnover report:', error);\n        process.exit(1);\n    }\n}\n\nmain();

// n8n workflow node: GitHub PR Trigger\n{\n  \"nodes\": [\n    {\n      \"parameters\": {\n        \"owner\": \"my-org\",\n        \"repo\": \"core-services\",\n        \"events\": [\"pull_request.opened\", \"pull_request.reopened\"]\n      },\n      \"id\": \"github-trigger\",\n      \"name\": \"GitHub PR Trigger\",\n      \"type\": \"n8n-nodes-base.githubTrigger\",\n      \"typeVersion\": 1,\n      \"position\": [250, 300]\n    },\n    {\n      \"parameters\": {\n        \"channel\": \"backend-team\",\n        \"text\": \"New PR: {{$json.title}} by {{$json.user.login}} - {{$json.html_url}}\"\n      },\n      \"id\": \"slack-message\",\n      \"name\": \"Send Slack Message\",\n      \"type\": \"n8n-nodes-base.slack\",\n      \"typeVersion\": 1,\n      \"position\": [450, 300]\n    }\n  ]\n}

# Prometheus PR review time metric\npr_review_duration_hours{repo=\"core-services\", team=\"backend\"} 3.2\npr_review_duration_hours{repo=\"core-services\", team=\"frontend\"} 2.1\npr_review_duration_hours{repo=\"billing-service\", team=\"backend\"} 4.7

// Cal.com API desk booking snippet\nconst bookDesk = async (userId, date, deskId) => {\n  const response = await fetch('https://cal.com/api/v1/bookings', {\n    method: 'POST',\n    headers: {\n      'Authorization': `Bearer ${process.env.CALCOM_API_KEY}`,\n      'Content-Type': 'application/json'\n    },\n    body: JSON.stringify({\n      userId,\n      eventTypeId: 123, // In-office desk booking event type\n      start: new Date(date).toISOString(),\n      end: new Date(new Date(date).setHours(17, 0, 0, 0)).toISOString(),\n      metadata: { deskId }\n    })\n  });\n  return response.json();\n};