Master the strategies of leadership and interview: What Matters

#!/usr/bin/env python3
"""
Interview Candidate Scoring System v1.2
Calculates weighted scores for senior engineering candidates across
technical, leadership, and culture fit dimensions.
Author: Senior Engineer (15yr exp)
"""

import json
from typing import Dict, List, Optional
from dataclasses import dataclass

@dataclass
class CandidateScore:
    """Data class to hold candidate score breakdown"""
    technical: float
    leadership: float
    culture: float
    weighted_total: float
    disqualifying_flags: List[str]

class InterviewScorer:
    """Core scoring logic for interview loops"""

    # Weightings validated by 300+ interview dataset
    TECH_WEIGHT = 0.45
    LEADERSHIP_WEIGHT = 0.35
    CULTURE_WEIGHT = 0.20

    # Minimum passing scores per dimension
    MIN_TECH = 70.0
    MIN_LEADERSHIP = 65.0
    MIN_CULTURE = 60.0

    def __init__(self, config_path: Optional[str] = None):
        self.config = self._load_config(config_path) if config_path else {}

    def _load_config(self, path: str) -> Dict:
        """Load custom weightings from JSON config"""
        try:
            with open(path, 'r') as f:
                return json.load(f)
        except FileNotFoundError:
            raise ValueError(f"Config file not found: {path}")
        except json.JSONDecodeError:
            raise ValueError(f"Invalid JSON in config: {path}")

    def calculate_score(self, tech_score: float, leadership_score: float, 
                        culture_score: float) -> CandidateScore:
        """
        Calculate weighted total score and check for disqualifying flags.

        Args:
            tech_score: 0-100 technical assessment score
            leadership_score: 0-100 leadership scenario score
            culture_score: 0-100 culture fit score

        Returns:
            CandidateScore with breakdown and flags
        """
        # Validate input ranges
        for score, name in [(tech_score, "Technical"), (leadership_score, "Leadership"), 
                           (culture_score, "Culture")]:
            if not 0 <= score <= 100:
                raise ValueError(f"{name} score must be 0-100, got {score}")

        # Apply custom weightings if provided
        tech_weight = self.config.get("tech_weight", self.TECH_WEIGHT)
        leadership_weight = self.config.get("leadership_weight", self.LEADERSHIP_WEIGHT)
        culture_weight = self.config.get("culture_weight", self.CULTURE_WEIGHT)

        # Calculate weighted total
        weighted_total = (tech_score * tech_weight) + \
                        (leadership_score * leadership_weight) + \
                        (culture_score * culture_weight)

        # Check for disqualifying flags
        flags = []
        if tech_score < self.MIN_TECH:
            flags.append(f"Technical score {tech_score} below minimum {self.MIN_TECH}")
        if leadership_score < self.MIN_LEADERSHIP:
            flags.append(f"Leadership score {leadership_score} below minimum {self.MIN_LEADERSHIP}")
        if culture_score < self.MIN_CULTURE:
            flags.append(f"Culture score {culture_score} below minimum {self.MIN_CULTURE}")

        return CandidateScore(
            technical=tech_score,
            leadership=leadership_score,
            culture=culture_score,
            weighted_total=round(weighted_total, 2),
            disqualifying_flags=flags
        )

if __name__ == "__main__":
    # Example usage
    scorer = InterviewScorer()
    try:
        candidate = scorer.calculate_score(82.5, 78.0, 91.0)
        print(f"Candidate Total Score: {candidate.weighted_total}")
        print(f"Disqualifying Flags: {candidate.disqualifying_flags if candidate.disqualifying_flags else 'None'}")
    except ValueError as e:
        print(f"Scoring Error: {e}")

package main

import (
    "encoding/json"
    "errors"
    "fmt"
    "os"
    "time"
)

// TeamHealthMetric represents a single health check for an engineering team
type TeamHealthMetric struct {
    ID          string    `json:"id"`
    TeamName    string    `json:"team_name"`
    Date        time.Time `json:"date"`
    Turnover    float64   `json:"turnover_percent"` // 6mo rolling turnover
    FeedbackScore float64 `json:"feedback_score"` // 0-100 from anonymous survey
    OnCallBurden float64 `json:"on_call_burden"` // avg hours/week per engineer
    DeliveryRate float64 `json:"delivery_rate"` // story points per sprint
}

// HealthThresholds defines minimum acceptable values for metrics
type HealthThresholds struct {
    MaxTurnover    float64 `json:"max_turnover"`
    MinFeedback    float64 `json:"min_feedback"`
    MaxOnCall      float64 `json:"max_on_call"`
    MinDelivery    float64 `json:"min_delivery"`
}

// TeamHealthTracker loads metrics, checks against thresholds, and generates alerts
type TeamHealthTracker struct {
    thresholds HealthThresholds
    metrics    []TeamHealthMetric
}

// NewTeamHealthTracker initializes a tracker with thresholds from config
func NewTeamHealthTracker(configPath string) (*TeamHealthTracker, error) {
    // Load thresholds from JSON config
    thresholds, err := loadThresholds(configPath)
    if err != nil {
        return nil, fmt.Errorf("failed to load thresholds: %w", err)
    }

    return &TeamHealthTracker{
        thresholds: thresholds,
        metrics:    []TeamHealthMetric{},
    }, nil
}

// loadThresholds reads and parses threshold config from disk
func loadThresholds(path string) (HealthThresholds, error) {
    file, err := os.ReadFile(path)
    if err != nil {
        return HealthThresholds{}, fmt.Errorf("config read error: %w", err)
    }

    var thresholds HealthThresholds
    if err := json.Unmarshal(file, &thresholds); err != nil {
        return HealthThresholds{}, fmt.Errorf("config parse error: %w", err)
    }

    // Validate thresholds are within reasonable ranges
    if thresholds.MaxTurnover < 0 || thresholds.MaxTurnover > 100 {
        return HealthThresholds{}, errors.New("max turnover must be 0-100")
    }
    if thresholds.MinFeedback < 0 || thresholds.MinFeedback > 100 {
        return HealthThresholds{}, errors.New("min feedback must be 0-100")
    }

    return thresholds, nil
}

// AddMetric appends a new health metric to the tracker
func (t *TeamHealthTracker) AddMetric(metric TeamHealthMetric) error {
    if metric.Turnover < 0 || metric.Turnover > 100 {
        return errors.New("turnover must be 0-100 percent")
    }
    if metric.FeedbackScore < 0 || metric.FeedbackScore > 100 {
        return errors.New("feedback score must be 0-100")
    }

    t.metrics = append(t.metrics, metric)
    return nil
}

// GenerateAlerts checks all metrics against thresholds and returns alerts
func (t *TeamHealthTracker) GenerateAlerts() []string {
    var alerts []string

    for _, m := range t.metrics {
        if m.Turnover > t.thresholds.MaxTurnover {
            alerts = append(alerts, fmt.Sprintf(
                "[%s] High turnover: %.1f%% (max %.1f%%)",
                m.TeamName, m.Turnover, t.thresholds.MaxTurnover,
            ))
        }
        if m.FeedbackScore < t.thresholds.MinFeedback {
            alerts = append(alerts, fmt.Sprintf(
                "[%s] Low feedback score: %.1f (min %.1f)",
                m.TeamName, m.FeedbackScore, t.thresholds.MinFeedback,
            ))
        }
        if m.OnCallBurden > t.thresholds.MaxOnCall {
            alerts = append(alerts, fmt.Sprintf(
                "[%s] High on-call burden: %.1f hrs/week (max %.1f)",
                m.TeamName, m.OnCallBurden, t.thresholds.MaxOnCall,
            ))
        }
    }

    return alerts
}

func main() {
    // Example usage
    tracker, err := NewTeamHealthTracker("health_thresholds.json")
    if err != nil {
        fmt.Printf("Initialization error: %v\n", err)
        os.Exit(1)
    }

    // Add sample metric
    err = tracker.AddMetric(TeamHealthMetric{
        ID:          "team-123",
        TeamName:    "Backend Payments",
        Date:        time.Now(),
        Turnover:    18.0,
        FeedbackScore: 62.0,
        OnCallBurden: 12.5,
        DeliveryRate: 42.0,
    })
    if err != nil {
        fmt.Printf("Metric add error: %v\n", err)
        os.Exit(1)
    }

    alerts := tracker.GenerateAlerts()
    if len(alerts) == 0 {
        fmt.Println("No health alerts for tracked teams")
    } else {
        fmt.Println("Team Health Alerts:")
        for _, alert := range alerts {
            fmt.Println("-", alert)
        }
    }
}

/**
 * Interview Feedback Generator v2.1
 * Generates personalized, actionable feedback for senior engineering candidates
 * based on scored dimensions and company benchmarks.
 */

import fs from 'fs';
import path from 'path';

type InterviewDimension = 'technical' | 'leadership' | 'culture';

interface CandidateResult {
  candidateId: string;
  name: string;
  scores: Record; // 0-100 per dimension
  weightedTotal: number;
  disqualifyingFlags: string[];
  targetRole: 'senior-backend' | 'senior-frontend' | 'staff';
}

interface BenchmarkData {
  role: string;
  avgScore: number;
  top25Percent: number;
  minPassing: number;
}

interface FeedbackSection {
  dimension: InterviewDimension;
  score: number;
  benchmarkComparison: string;
  strengths: string[];
  improvements: string[];
}

class InterviewFeedbackGenerator {
  private benchmarks: BenchmarkData[] = [];
  private feedbackTemplates: Record = {};

  constructor(benchmarkPath: string, templatePath: string) {
    this.loadBenchmarks(benchmarkPath);
    this.loadTemplates(templatePath);
  }

  /**
   * Load role-specific benchmark data from JSON
   */
  private loadBenchmarks(filePath: string): void {
    try {
      const raw = fs.readFileSync(filePath, 'utf-8');
      this.benchmarks = JSON.parse(raw);
    } catch (err) {
      throw new Error(`Failed to load benchmarks: ${err instanceof Error ? err.message : String(err)}`);
    }
  }

  /**
   * Load feedback templates from JSON
   */
  private loadTemplates(filePath: string): void {
    try {
      const raw = fs.readFileSync(filePath, 'utf-8');
      this.feedbackTemplates = JSON.parse(raw);
    } catch (err) {
      throw new Error(`Failed to load templates: ${err instanceof Error ? err.message : String(err)}`);
    }
  }

  /**
   * Get benchmark data for a specific role
   */
  private getBenchmarkForRole(role: string): BenchmarkData {
    const benchmark = this.benchmarks.find(b => b.role === role);
    if (!benchmark) {
      throw new Error(`No benchmark data found for role: ${role}`);
    }
    return benchmark;
  }

  /**
   * Generate feedback sections for each scored dimension
   */
  private generateDimensionFeedback(
    dimension: InterviewDimension,
    score: number,
    benchmark: BenchmarkData
  ): FeedbackSection {
    const comparison = score > benchmark.top25Percent 
      ? `Top 25% of candidates for ${benchmark.role}`
      : score > benchmark.avgScore 
        ? `Above average for ${benchmark.role}`
        : `Below average for ${benchmark.role}`;

    // Get template for dimension
    const template = this.feedbackTemplates[dimension] || 'No template found for dimension';

    return {
      dimension,
      score,
      benchmarkComparison: comparison,
      strengths: this.extractStrengths(dimension, score, benchmark),
      improvements: this.extractImprovements(dimension, score, benchmark),
    };
  }

  /**
   * Extract strengths based on score and benchmark
   */
  private extractStrengths(dimension: InterviewDimension, score: number, benchmark: BenchmarkData): string[] {
    const strengths: string[] = [];
    if (score >= benchmark.top25Percent) {
      strengths.push(`Demonstrated exceptional ${dimension} skills, exceeding top 25% of candidates`);
    } else if (score >= benchmark.avgScore) {
      strengths.push(`Solid ${dimension} performance, above role average`);
    }
    return strengths;
  }

  /**
   * Extract improvement areas based on score and benchmark
   */
  private extractImprovements(dimension: InterviewDimension, score: number, benchmark: BenchmarkData): string[] {
    const improvements: string[] = [];
    if (score < benchmark.minPassing) {
      improvements.push(`Score below minimum passing threshold of ${benchmark.minPassing} for ${dimension}`);
    } else if (score < benchmark.avgScore) {
      improvements.push(`Below average performance for ${dimension}, review core concepts`);
    }
    return improvements;
  }

  /**
   * Generate full feedback report for a candidate
   */
  public generateFeedback(candidate: CandidateResult): string {
    const benchmark = this.getBenchmarkForRole(candidate.targetRole);
    const sections = (Object.keys(candidate.scores) as InterviewDimension[]).map(dim => 
      this.generateDimensionFeedback(dim, candidate.scores[dim], benchmark)
    );

    // Build feedback string
    let feedback = `Interview Feedback for ${candidate.name} (${candidate.candidateId})\n`;
    feedback += `Target Role: ${candidate.targetRole}\n`;
    feedback += `Weighted Total Score: ${candidate.weightedTotal}\n`;
    feedback += `Disqualifying Flags: ${candidate.disqualifyingFlags.length > 0 ? candidate.disqualifyingFlags.join(', ') : 'None'}\n\n`;

    sections.forEach(section => {
      feedback += `--- ${section.dimension.toUpperCase()} (Score: ${section.score}) ---\n`;
      feedback += `Benchmark: ${section.benchmarkComparison}\n`;
      if (section.strengths.length > 0) {
        feedback += `Strengths: ${section.strengths.join('; ')}\n`;
      }
      if (section.improvements.length > 0) {
        feedback += `Improvements: ${section.improvements.join('; ')}\n`;
      }
      feedback += '\n';
    });

    return feedback;
  }
}

// Example usage
try {
  const generator = new InterviewFeedbackGenerator(
    path.join(__dirname, 'benchmarks.json'),
    path.join(__dirname, 'feedback-templates.json')
  );

  const sampleCandidate: CandidateResult = {
    candidateId: 'cand-456',
    name: 'Alex Chen',
    scores: { technical: 82, leadership: 78, culture: 91 },
    weightedTotal: 82.4,
    disqualifyingFlags: [],
    targetRole: 'senior-backend',
  };

  const feedback = generator.generateFeedback(sampleCandidate);
  console.log(feedback);
} catch (err) {
  console.error('Feedback generation error:', err instanceof Error ? err.message : String(err));
}

# Exercise: Optimize a slow user lookup query
# Given this ORM query that takes 1200ms for 10k users:
# User.objects.filter(created_at__gte='2023-01-01').order_by('-last_login')

# Your task: Rewrite the query to run in <200ms, explain your changes,
# and add a database index migration.

{
  "question": "My manager provides actionable, specific feedback on my work at least once per sprint",
  "type": "likert-5",
  "options": ["Strongly Disagree", "Disagree", "Neutral", "Agree", "Strongly Agree"]
}

Situation: Our payment API had 2.4s p99 latency, causing 12% cart abandonment.
Task: Reduce p99 latency to <300ms within 6 weeks without increasing infra cost.
Action: Migrated from ORM queries to raw SQL with prepared statements, added Redis caching for hot user data, and implemented connection pooling.
Result: p99 dropped to 180ms, cart abandonment fell to 3%, saving $18k/month.
Learning: I now audit all ORM queries for N+1 issues during code review, and added a latency benchmark to our CI pipeline.