Guía del manager para una contratación técnica que funciona

// ❌ Technology-focused requirements that miss the point
interface BadJobRequirements {
  technologies: string[];
  yearsExperience: number;
  education: string;
}
 
const typicalListing: BadJobRequirements = {
  technologies: [
    "React", "TypeScript", "Node.js", "PostgreSQL",
    "Redis", "Docker", "Kubernetes", "AWS",
  ],
  yearsExperience: 5,
  education: "BS in Computer Science",
};
// Tests: memory of technology names
// Misses: problem-solving, communication, learning ability

// ✅ Capability-focused requirements that predict success
interface RoleCapability {
  capability: string;
  importance: "critical" | "important" | "nice-to-have";
  howToAssess: string;
}
 
const seniorFrontendRole: RoleCapability[] = [
  {
    capability: "Break down ambiguous problems into implementable tasks",
    importance: "critical",
    howToAssess: "System design discussion with real product scenario",
  },
  {
    capability: "Debug complex state management issues across components",
    importance: "critical",
    howToAssess: "Debugging exercise with realistic codebase",
  },
  {
    capability: "Communicate technical trade-offs to non-technical stakeholders",
    importance: "important",
    howToAssess: "Behavioral questions about past decisions",
  },
  {
    capability: "Mentor junior developers through code review and pairing",
    importance: "important",
    howToAssess: "Mock code review exercise",
  },
  {
    capability: "Optimize frontend performance for real user metrics",
    importance: "nice-to-have",
    howToAssess: "Discussion of past performance work with metrics",
  },
];

interface InterviewQuestion {
  id: string;
  question: string;
  capabilityAssessed: string;
  rubric: {
    score: 1 | 2 | 3 | 4;
    description: string;
    examples: string[];
  }[];
  followUps: string[];
}
 
const sampleQuestion: InterviewQuestion = {
  id: "system-design-01",
  question:
    "You're building a real-time notification system for a web app " +
    "with 100K daily active users. Walk me through your approach.",
  capabilityAssessed: "Break down ambiguous problems into implementable tasks",
  rubric: [
    {
      score: 1,
      description: "Cannot structure approach, jumps to implementation",
      examples: ["Immediately talks about specific libraries without understanding requirements"],
    },
    {
      score: 2,
      description: "Identifies some requirements but misses key constraints",
      examples: ["Discusses real-time delivery but ignores scalability and failure modes"],
    },
    {
      score: 3,
      description: "Systematic approach covering major concerns",
      examples: [
        "Identifies delivery guarantees, connection management, scalability",
        "Discusses trade-offs between SSE, WebSocket, polling",
      ],
    },
    {
      score: 4,
      description: "Thorough analysis with nuanced trade-offs and experience-backed insights",
      examples: [
        "Discusses fan-out patterns, reconnection strategies, message ordering",
        "References specific production experience with similar systems",
      ],
    },
  ],
  followUps: [
    "What happens when a user has been offline for a week?",
    "How would you handle this at 10x the scale?",
    "What monitoring would you set up?",
  ],
};

interface TakeHomeExercise {
  title: string;
  description: string;
  timeLimit: string;
  evaluationCriteria: {
    criterion: string;
    weight: number;
  }[];
  whatWeWontEvaluate: string[];
}
 
const goodExercise: TakeHomeExercise = {
  title: "Build a paginated data table component",
  description:
    "Create a reusable table component that fetches data from " +
    "the provided API endpoint, supports pagination, sorting by " +
    "column, and basic filtering. Use any framework or vanilla JS. " +
    "Include a README explaining your decisions.",
  timeLimit: "3 hours maximum (honor system, we mean it)",
  evaluationCriteria: [
    { criterion: "Working solution that meets core requirements", weight: 30 },
    { criterion: "Code organization and readability", weight: 25 },
    { criterion: "Error handling and edge cases", weight: 20 },
    { criterion: "Documentation of decisions and trade-offs", weight: 15 },
    { criterion: "Test coverage for critical paths", weight: 10 },
  ],
  whatWeWontEvaluate: [
    "Visual design or CSS polish",
    "Use of any specific library or framework",
    "Performance optimization beyond reasonable",
    "100% test coverage",
  ],
};

// ❌ Bad take-home signals
const badExercise = {
  timeEstimate: "This should take about 4-6 hours",
  // Reality: 10-15 hours for a good submission
  scope: "Build a full-stack app with auth, CRUD, and deployment",
  // Disrespects candidate's time
  evaluation: "We'll review the code and get back to you",
  // Vague criteria means subjective evaluation
};
 
// ✅ Respect candidates' time
const exercisePolicy = {
  maxTime: "3 hours strict",
  compensation: "Paid at $75/hour for submissions that reach review",
  turnaround: "Feedback within 3 business days regardless of outcome",
  followUp: "30-min live session to discuss approach and extend solution",
};

interface CalibrationSession {
  purpose: string;
  frequency: string;
  process: string[];
}
 
const calibrationProcess: CalibrationSession = {
  purpose:
    "Align interviewers on scoring standards and reduce variance",
  frequency: "Monthly, or when onboarding new interviewers",
  process: [
    "Review 3-5 recent interview scorecards as a group",
    "Each interviewer scores independently before discussion",
    "Compare scores and discuss disagreements",
    "Identify patterns: who scores high/low consistently",
    "Agree on calibrated examples for each score level",
    "Shadow experienced interviewers for new panelists",
  ],
};
 
interface InterviewerMetrics {
  interviewerId: string;
  averageScore: number;
  hireRate: number;
  candidatesWhoAccepted: number;
  hiredCandidatePerformance: number; // 1-year review average
}
 
function identifyCalibrationNeeds(
  metrics: InterviewerMetrics[]
): string[] {
  const issues: string[] = [];
  const avgHireRate =
    metrics.reduce((s, m) => s + m.hireRate, 0) / metrics.length;
 
  for (const m of metrics) {
    if (m.hireRate > avgHireRate * 1.5) {
      issues.push(
        `${m.interviewerId}: hire rate ${(m.hireRate * 100).toFixed(0)}% ` +
        `is significantly above average (${(avgHireRate * 100).toFixed(0)}%). ` +
        `May need to raise the bar.`
      );
    }
    if (m.hireRate < avgHireRate * 0.5) {
      issues.push(
        `${m.interviewerId}: hire rate ${(m.hireRate * 100).toFixed(0)}% ` +
        `is significantly below average. May be too strict or ` +
        `assessing the wrong things.`
      );
    }
    if (m.candidatesWhoAccepted < metrics.length * 0.3) {
      issues.push(
        `${m.interviewerId}: low acceptance rate. ` +
        `Check candidate experience in their interviews.`
      );
    }
  }
 
  return issues;
}

interface CandidateExperienceMetrics {
  timeToFirstResponse: number;   // hours
  totalProcessDuration: number;  // days
  interviewRoundsCount: number;
  feedbackProvided: boolean;
  candidateSatisfaction: number; // 1-5
}
 
function evaluateHiringProcess(
  metrics: CandidateExperienceMetrics[]
): { score: string; improvements: string[] } {
  const improvements: string[] = [];
 
  const avgFirstResponse =
    metrics.reduce((s, m) => s + m.timeToFirstResponse, 0) /
    metrics.length;
 
  if (avgFirstResponse > 48) {
    improvements.push(
      `First response averages ${avgFirstResponse.toFixed(0)}h. ` +
      `Target: under 24h. Automate initial screening.`
    );
  }
 
  const avgDuration =
    metrics.reduce((s, m) => s + m.totalProcessDuration, 0) /
    metrics.length;
 
  if (avgDuration > 21) {
    improvements.push(
      `Process takes ${avgDuration.toFixed(0)} days average. ` +
      `Top candidates drop off after 14 days.`
    );
  }
 
  const feedbackRate =
    metrics.filter(m => m.feedbackProvided).length / metrics.length;
 
  if (feedbackRate < 0.9) {
    improvements.push(
      `Only ${(feedbackRate * 100).toFixed(0)}% of candidates receive feedback. ` +
      `Every candidate deserves a response.`
    );
  }
 
  const score =
    improvements.length === 0
      ? "excellent"
      : improvements.length <= 2
        ? "good"
        : "needs work";
 
  return { score, improvements };
}