Implementing a Stay Interview Program

interface StayInterviewSchedule {
  employeeSegment: string;
  frequency: string;
  interviewer: string;
  duration: number;
}

const scheduleGuidelines: StayInterviewSchedule[] = [
  {
    employeeSegment: 'High performers',
    frequency: 'Every 6 months',
    interviewer: 'Skip-level manager',
    duration: 60
  },
  {
    employeeSegment: 'Flight risk indicators',
    frequency: 'Every 3 months',
    interviewer: 'Direct manager + HR',
    duration: 45
  },
  {
    employeeSegment: 'New hires (< 6 months)',
    frequency: 'At 90 days',
    interviewer: 'Direct manager',
    duration: 30
  },
  {
    employeeSegment: 'General population',
    frequency: 'Annually',
    interviewer: 'Direct manager',
    duration: 45
  }
];

class StayInterviewTraining:
    """Training framework for stay interview conductors"""

    core_skills = {
        'active_listening': {
            'description': 'Focus fully on responses without planning your reply',
            'practice_exercise': 'Listen for 3 minutes without speaking',
            'mastery_indicator': 'Can summarize without notes'
        },
        'psychological_safety': {
            'description': 'Create environment where honest feedback feels safe',
            'practice_exercise': 'Role-play difficult conversations',
            'mastery_indicator': 'Employee shares genuine concerns'
        },
        'follow_up_questions': {
            'description': 'Dig deeper into surface-level answers',
            'practice_exercise': 'Ask "why" or "tell me more" 3x per question',
            'mastery_indicator': 'Uncover root causes, not symptoms'
        },
        'neutrality': {
            'description': 'Avoid defensive reactions to feedback',
            'practice_exercise': 'Respond to criticism with curiosity',
            'mastery_indicator': 'No visible negative reaction to hard feedback'
        }
    }

    @staticmethod
    def assess_readiness(interviewer_name: str, skill_scores: dict) -> bool:
        """Determine if interviewer is ready to conduct stay interviews"""
        required_threshold = 7  # out of 10
        all_skills_sufficient = all(score >= required_threshold for score in skill_scores.values())

        return all_skills_sufficient

# Example usage
sarah_scores = {
    'active_listening': 8,
    'psychological_safety': 7,
    'follow_up_questions': 9,
    'neutrality': 6  # Needs more practice
}

is_ready = StayInterviewTraining.assess_readiness('Sarah', sarah_scores)
print(f"Ready to conduct: {is_ready}")  # False - neutrality needs work

interface StayInterviewInsight {
  employee: string;
  concern: string;
  category: 'Individual' | 'Team' | 'Organizational';
  urgency: 'High' | 'Medium' | 'Low';
  actionability: 'Quick Win' | 'Project' | 'Strategic';
  owner: string;
}

class ActionPrioritization {
  prioritize(insights: StayInterviewInsight[]): StayInterviewInsight[] {
    // Sort by impact and feasibility
    return insights.sort((a, b) => {
      // High urgency first
      if (a.urgency === 'High' && b.urgency !== 'High') return -1;
      if (b.urgency === 'High' && a.urgency !== 'High') return 1;

      // Quick wins next
      if (a.actionability === 'Quick Win' && b.actionability !== 'Quick Win') return -1;
      if (b.actionability === 'Quick Win' && a.actionability !== 'Quick Win') return 1;

      return 0;
    });
  }

  generateActionPlan(insight: StayInterviewInsight): ActionPlan {
    const plan: ActionPlan = {
      insight: insight.concern,
      owner: insight.owner,
      timeline: this.getTimeline(insight.actionability),
      steps: this.getSteps(insight.category, insight.actionability),
      successMetric: this.getMetric(insight.category)
    };

    return plan;
  }

  private getTimeline(actionability: string): string {
    const timelines = {
      'Quick Win': '1-2 weeks',
      'Project': '1-3 months',
      'Strategic': '6-12 months'
    };
    return timelines[actionability] || '1 month';
  }

  private getSteps(category: string, actionability: string): string[] {
    // Implementation details for different scenario combinations
    return [];
  }

  private getMetric(category: string): string {
    const metrics = {
      'Individual': 'Employee satisfaction increase',
      'Team': 'Team engagement score improvement',
      'Organizational': 'Retention rate improvement'
    };
    return metrics[category];
  }
}

interface ActionPlan {
  insight: string;
  owner: string;
  timeline: string;
  steps: string[];
  successMetric: string;
}

## Stay Interview Action Plan

**Employee:** Jane Doe
**Interview Date:** 2025-12-18
**Interviewer:** Sarah Chen

### Key Insights

1. **Wants more strategic work** (Individual, High urgency, Quick win)
   - Action: Assign to Q1 product strategy project
   - Owner: Direct manager
   - Timeline: Next sprint (2 weeks)
   - Success: Jane leading 1+ strategic initiative

2. **Unclear career path** (Individual, Medium urgency, Project)
   - Action: Create personalized development plan
   - Owner: Manager + HR
   - Timeline: 1 month
   - Success: Written plan with milestones

3. **Team lacks collaboration tools** (Team, Medium urgency, Quick win)
   - Action: Implement Miro for design collaboration
   - Owner: Team lead
   - Timeline: 2 weeks
   - Success: Team using tool weekly

### Follow-up Schedule

- Week 1: Confirm strategic project assignment
- Week 2: Schedule development planning session
- Month 1: Check in on progress
- Month 3: Follow-up stay interview

import pandas as pd
from datetime import datetime, timedelta

class StayInterviewMetrics:
    def __init__(self, interviews: list, actions: list, retention_data: list):
        self.interviews_df = pd.DataFrame(interviews)
        self.actions_df = pd.DataFrame(actions)
        self.retention_df = pd.DataFrame(retention_data)

    def calculate_participation_rate(self, month: str) -> float:
        """Calculate % of scheduled interviews completed"""
        monthly = self.interviews_df[self.interviews_df['month'] == month]
        return (monthly['status'] == 'Completed').sum() / len(monthly)

    def action_completion_rate(self) -> float:
        """Calculate % of action items completed on time"""
        completed = self.actions_df['status'] == 'Completed'
        on_time = self.actions_df['completed_date'] <= self.actions_df['due_date']
        return (completed & on_time).sum() / len(self.actions_df)

    def retention_impact(self) -> dict:
        """Compare retention rates: interviewed vs not interviewed"""
        interviewed = self.retention_df[self.retention_df['had_stay_interview'] == True]
        not_interviewed = self.retention_df[self.retention_df['had_stay_interview'] == False]

        return {
            'interviewed_retention': (interviewed['still_employed']).sum() / len(interviewed),
            'not_interviewed_retention': (not_interviewed['still_employed']).sum() / len(not_interviewed),
            'improvement': ((interviewed['still_employed']).sum() / len(interviewed)) -
                          ((not_interviewed['still_employed']).sum() / len(not_interviewed))
        }

    def early_warning_effectiveness(self) -> float:
        """Calculate success rate of intervention with at-risk employees"""
        at_risk = self.interviews_df[self.interviews_df['flight_risk'] == True]
        prevented = at_risk[at_risk['still_employed_90_days'] == True]
        return len(prevented) / len(at_risk) if len(at_risk) &gt; 0 else 0

from sklearn.ensemble import RandomForestClassifier
import pandas as pd

class RetentionRiskModel:
    """Predict flight risk based on stay interview responses"""

    def __init__(self):
        self.model = RandomForestClassifier(n_estimators=100)
        self.features = [
            'likely_to_stay_score',  # 1-10 from magic question
            'development_satisfaction',  # 1-10
            'manager_relationship',  # 1-10
            'role_clarity',  # 1-10
            'recognition_frequency',  # 1-10
            'workload_balance',  # 1-10
            'career_path_clarity'  # 1-10
        ]

    def train(self, historical_data: pd.DataFrame):
        """Train model on past stay interviews and outcomes"""
        X = historical_data[self.features]
        y = historical_data['left_within_6_months']
        self.model.fit(X, y)

    def predict_risk(self, interview_responses: dict) -> tuple:
        """Predict if employee is flight risk based on responses"""
        X = pd.DataFrame([interview_responses])[self.features]
        risk_probability = self.model.predict_proba(X)[0][1]
        risk_level = 'High' if risk_probability > 0.7 else 'Medium' if risk_probability > 0.4 else 'Low'

        return risk_level, risk_probability

# Usage
model = RetentionRiskModel()
# Train with historical data
# model.train(past_interviews_df)

# Predict on new interview
new_responses = {
    'likely_to_stay_score': 6,
    'development_satisfaction': 4,
    'manager_relationship': 8,
    'role_clarity': 7,
    'recognition_frequency': 3,
    'workload_balance': 5,
    'career_path_clarity': 4
}

risk, probability = model.predict_risk(new_responses)
print(f"Risk Level: {risk}, Probability: {probability:.2%}")