El camino hacia Staff Engineer: más allá de Senior

interface EngineeringLevel {
  title: string;
  scope: string;
  primaryOutput: string;
  evaluatedOn: string[];
  timeAllocation: {
    coding: number;
    design: number;
    communication: number;
    mentoring: number;
  };
}
 
const seniorEngineer: EngineeringLevel = {
  title: "Senior Engineer",
  scope: "Team — owns complex features end to end",
  primaryOutput: "Working software and technical quality",
  evaluatedOn: [
    "Feature delivery speed and quality",
    "Code review thoroughness",
    "Technical mentoring within the team",
    "Handling on-call and incidents",
  ],
  timeAllocation: {
    coding: 60,
    design: 15,
    communication: 15,
    mentoring: 10,
  },
};
 
const staffEngineer: EngineeringLevel = {
  title: "Staff Engineer",
  scope: "Organization — influences technical direction across teams",
  primaryOutput: "Technical strategy and leveling-up others",
  evaluatedOn: [
    "Cross-team technical alignment",
    "Identifying and solving org-level problems",
    "Raising the engineering bar across teams",
    "Unblocking others on ambiguous problems",
    "Technical vision and strategy documents",
  ],
  timeAllocation: {
    coding: 30,
    design: 30,
    communication: 25,
    mentoring: 15,
  },
};

interface StaffArchetype {
  name: string;
  description: string;
  activities: string[];
  strengths: string[];
  risks: string[];
}
 
const archetypes: StaffArchetype[] = [
  {
    name: "Tech Lead",
    description: "Guides a team or group's technical direction",
    activities: [
      "Sets technical direction for complex projects",
      "Partners with product and engineering managers",
      "Ensures technical quality through design reviews",
      "Balances technical debt paydown with feature work",
    ],
    strengths: [
      "Deep empathy for team dynamics",
      "Strong project execution instincts",
    ],
    risks: [
      "Becoming a shadow manager",
      "Losing technical depth over time",
    ],
  },
  {
    name: "Architect",
    description: "Designs systems that span multiple teams",
    activities: [
      "Creates technical vision documents",
      "Reviews cross-team system designs",
      "Defines standards and patterns",
      "Evaluates build-vs-buy decisions",
    ],
    strengths: [
      "Broad technical knowledge across domains",
      "Long-term systems thinking",
    ],
    risks: [
      "Ivory tower disconnection from implementation",
      "Designing systems nobody can build",
    ],
  },
  {
    name: "Solver",
    description: "Parachutes into critical problems across the org",
    activities: [
      "Debugs the hardest production issues",
      "Tackles high-risk migrations",
      "Unblocks stalled technical projects",
      "Prototypes solutions for ambiguous problems",
    ],
    strengths: [
      "Deep technical expertise",
      "Comfort with ambiguity and pressure",
    ],
    risks: [
      "Becoming a bottleneck or hero",
      "Not building lasting organizational capability",
    ],
  },
  {
    name: "Right Hand",
    description: "Extends an executive's technical reach",
    activities: [
      "Represents engineering in cross-functional decisions",
      "Translates strategy into technical plans",
      "Monitors technical health across the org",
      "Facilitates alignment between engineering groups",
    ],
    strengths: [
      "Organizational awareness and influence",
      "Communication across technical and business contexts",
    ],
    risks: [
      "Losing individual contributor identity",
      "Role ambiguity with engineering managers",
    ],
  },
];

// ❌ Common approach: verbal opinions in meetings
const ineffective = {
  approach: "Share technical opinion in team standup",
  reach: "5-8 people who happened to be in the meeting",
  persistence: "Forgotten by next week",
  influence: "Limited to local team decisions",
};
 
// ✅ Staff approach: written artifacts that scale
const effective = {
  approach: "Write technical strategy document",
  reach: "Entire engineering org, asynchronously",
  persistence: "Referenced for months, updated as context changes",
  influence: "Shapes decisions across multiple teams",
};

interface TechnicalDocument {
  type: string;
  audience: string;
  purpose: string;
  structure: string[];
}
 
const staffDocuments: TechnicalDocument[] = [
  {
    type: "Technical Vision",
    audience: "Engineering org + leadership",
    purpose: "Describe desired future state and path to get there",
    structure: [
      "Current state: where are we and what problems exist",
      "Desired state: what does success look like in 12-18 months",
      "Gap analysis: what needs to change",
      "Migration strategy: how we get from here to there",
      "Success metrics: how we measure progress",
    ],
  },
  {
    type: "Architecture Decision Record",
    audience: "Engineering teams affected by the decision",
    purpose: "Explain what was decided, why, and what alternatives were considered",
    structure: [
      "Context: the problem and constraints",
      "Decision: what we chose",
      "Alternatives considered: what we didn't choose and why",
      "Consequences: trade-offs and what to watch for",
      "Review date: when to reassess this decision",
    ],
  },
  {
    type: "Investigation Report",
    audience: "Product and engineering leadership",
    purpose: "Summarize findings and recommend action on a technical problem",
    structure: [
      "Problem statement: what's happening and the business impact",
      "Investigation findings: root causes with evidence",
      "Options with trade-offs: at least 3 approaches",
      "Recommendation: preferred option with reasoning",
      "Resource estimate: effort and timeline for recommended option",
    ],
  },
];

interface InfluenceStrategy {
  strategy: string;
  howItWorks: string;
  example: string;
}
 
const influenceStrategies: InfluenceStrategy[] = [
  {
    strategy: "Build trust through small wins",
    howItWorks:
      "Help teams solve their immediate problems before proposing big changes",
    example:
      "Fix a team's flaky test suite before proposing a testing framework migration",
  },
  {
    strategy: "Make the right thing easy",
    howItWorks:
      "Instead of mandating practices, provide tools that make good practices effortless",
    example:
      "Build a CI template with security scanning built in rather than writing a policy doc",
  },
  {
    strategy: "Ask questions instead of giving answers",
    howItWorks:
      "Guide teams to discover the right approach rather than dictating solutions",
    example:
      "'What happens if this service gets 10x traffic?' instead of 'You need to add caching'",
  },
  {
    strategy: "Show, don't tell",
    howItWorks:
      "Prototype solutions that demonstrate value rather than writing proposals",
    example:
      "Build a working proof-of-concept for the new logging pipeline in an afternoon",
  },
  {
    strategy: "Create alignment through shared context",
    howItWorks:
      "Ensure decision-makers have the same information you have",
    example:
      "Send a weekly technical digest summarizing cross-team dependencies and risks",
  },
];

interface ImpactCategory {
  category: string;
  examples: string[];
  howToTrack: string;
}
 
const impactCategories: ImpactCategory[] = [
  {
    category: "Force multiplier",
    examples: [
      "Created shared library that saved 3 teams 2 weeks each",
      "Design review caught architecture flaw that would've caused a rewrite",
      "Mentored 2 engineers to senior level promotions",
    ],
    howToTrack: "Keep a running log of decisions influenced and time saved",
  },
  {
    category: "Risk reduction",
    examples: [
      "Identified and mitigated single points of failure before an outage",
      "Led migration off deprecated dependency before it became critical",
      "Established incident response process that cut MTTR by 40%",
    ],
    howToTrack: "Document what didn't happen because of your interventions",
  },
  {
    category: "Technical direction",
    examples: [
      "Authored API design standards adopted by all teams",
      "Led evaluation and selection of observability stack",
      "Created migration plan from monolith to services",
    ],
    howToTrack: "Link to documents, decisions, and adoption metrics",
  },
];