Nadie te dice esto sobre los niveles en programación

El junior pregunta "¿cómo hago esto?". El senior pregunta "¿esto debería existir?". Entre esas dos preguntas hay un mundo de diferencia que las empresas conocen pero rara vez explicitan.

Después de revisar cientos de perfiles y procesos de selección, acá está el mapa real de qué esperan las empresas en cada nivel — más allá de los buzzwords de las ofertas laborales.

Junior: Aprender a no romper todo

Rango típico: 0-2 años de experiencia

Habilidades técnicas esperadas

• Git básico que funciona: add, commit, push, pull. Si sabés hacer un merge sin conflictos, ya estás arriba del promedio
• Un lenguaje medianamente sólido: no necesitás ser experto, pero sí escribir código que otros puedan leer
• Debugging sistemático: usar el debugger en lugar de console.log por toda la app
• Tests básicos: escribir unit tests simples, entender por qué fallan

Lo que realmente evalúan

Capacidad de aprendizaje: ¿Podés pasar de no saber algo a implementarlo en tiempo razonable? Las empresas prefieren alguien que aprende rápido sobre alguien que "ya sabe todo".

Comunicación de bloqueos: "Estoy trabado con esto, intenté X e Y, ¿me podés dar una mano?" vs "No funciona" y desaparecer por 3 días.

Seguir procesos: si hay code review, lo usás. Si hay testing, escribís tests. Si hay documentación, la leés antes de preguntar.

Ejemplo real de evaluación junior

// Antes (junior problemático)
function calculatePrice(items) {
  let total = 0;
  for(let i = 0; i < items.length; i++) {
    total += items[i].price * items[i].quantity;
  }
  return total;
}

// Después (junior que progresa)
function calculateTotalPrice(items) {
  return items.reduce((total, item) => {
    return total + (item.price * item.quantity);
  }, 0);
}

// Tests incluidos
test('calculateTotalPrice sums item prices correctly', () => {
  const items = [
    { price: 10, quantity: 2 },
    { price: 5, quantity: 1 }
  ];
  expect(calculateTotalPrice(items)).toBe(25);
});

Semi-Senior: Conectar las piezas

Rango típico: 2-4 años de experiencia

Habilidades técnicas esperadas

• Arquitectura a nivel componente: diseñar módulos que se integren bien con el resto del sistema
• Performance consciente: identificar bottlenecks, optimizar queries, manejar estado eficientemente
• Git avanzado: branches, merges, rebases, cherry-picks sin sudar
• Testing estratégico: integration tests, mocks, coverage que tiene sentido

El salto mental clave

Acá es donde dejás de pensar "mi código" y empezás a pensar "nuestro código". Las decisiones técnicas tienen impacto en el equipo, y eso se nota.

Lo que realmente evalúan

Criterio técnico: ¿Podés elegir entre dos librerías justificando la decisión? ¿Sabés cuándo algo es over-engineering?

Mentoría básica: ayudar a juniors sin darles la solución masticada. "Probaste mirar la documentación de X?" en lugar de escribirles el código.

Estimaciones realistas: si decís que algo lleva 3 días, que sean 3-4 días, no 2 semanas.

Checklist semi-senior

• Podés revisar código de otros y dar feedback constructivo
• Manejás CI/CD básico (GitHub Actions, pipelines simples)
• Integrás APIs externas sin que se caiga todo cuando fallan
• Escribís documentación que otros entienden
• Participás en discussions técnicas con criterio

Senior: Del código a la estrategia

Rango típico: 4-7 años de experiencia

Habilidades técnicas esperadas

• Arquitectura de sistema: diseñar soluciones que escalen, no solo que funcionen
• Múltiples tecnologías: no necesitás ser experto en todo, pero sí entender trade-offs
• DevOps competente: deployment, monitoring, debugging en producción
• Security awareness: no ser un security expert, pero sí escribir código defensivo

El cambio de mentalidad

El senior no escribe más código, escribe mejor código. Y a veces, no escribir código es la mejor solución.

Lo que realmente evalúan

Impacto en el producto: tus decisiones técnicas se traduzcan en valor para el usuario y el negocio. Un refactor que mejora performance es genial; uno que solo "queda más lindo" no.

Liderazgo técnico: sin título formal, otros devs te consultan. Tus code reviews se toman en serio. Podés guiar architectural decisions.

Gestión de complejidad: sabés cuándo algo es genuinamente complejo vs cuándo lo estamos haciendo complejo. Y podés simplificar ambos casos.

Ejemplo de pensamiento senior

// Junior piensa: "¿Cómo almaceno esto?"
// Senior piensa: "¿Esto debería almacenarse?"

// En lugar de cachear todo
class DataManager {
  constructor() {
    this.cache = new Map();
    this.metrics = new MetricsCollector();
  }
  
  async getData(key) {
    // Senior considera: frecuencia de acceso, tamaño de data, 
    // invalidación, memoria disponible
    if (this.shouldCache(key)) {
      return this.getCached(key) || this.fetchAndCache(key);
    }
    return this.fetchDirect(key);
  }
  
  shouldCache(key) {
    // Lógica basada en métricas reales, no intuición
    return this.metrics.getAccessFrequency(key) > CACHE_THRESHOLD;
  }
}

Staff/Principal: El multiplier effect

Rango típico: 7+ años de experiencia

Más allá del código

En este nivel, tu impacto se mide por cómo mejorás la productividad de todo el equipo. Escribís menos código pero tus decisiones afectan más código.

Habilidades clave

Architectural vision: diseñás sistemas que van a durar años, no meses

Technical strategy: influenciás la hoja de ruta técnica de la empresa

Mentorship at scale: desarrollás otros seniors, no solo juniors

Cross-team collaboration: trabajás con producto, design, QA como equal partner

Ejemplo de impacto staff

En lugar de optimizar una función, rediseñás la arquitectura de microservices para que 3 equipos trabajen sin blockearse mutuamente. En lugar de escribir documentación, creás procesos que hacen que la documentación se escriba sola.

Technical Lead: Código + personas

El híbrido técnico-gestión

Technical lead no es un nivel de seniority, es un rol. Podés ser tech lead siendo senior, pero necesitás skills adicionales:

People management básico: 1-on-1s, feedback, desarrollo de carrera de tu equipo

Project management: planificar sprints, manejar dependencias, comunicar delays

Stakeholder management: traducir entre "business requirements" y "technical implementation"

La trampa común

Muchos devs senior asumen que tech lead = "senior que coordina". La realidad: es 50% técnico, 50% gestión de personas. Si no te gusta la segunda parte, tech lead no es para vos.

Engineering Manager: Personas > código

El salto más grande

Dejar de medir tu éxito por el código que escribís y empezar a medirlo por el código que tu equipo escribe.

Tu nueva métrica de éxito: ¿Tu equipo entrega software de calidad, a tiempo, y está contento trabajando?

Skills críticos:

• Hiring: identificar talento, hacer entrevistas técnicas justas
• Performance management: feedback regular, planes de desarrollo
• Planning: roadmaps, estimaciones a nivel equipo
• Culture: crear ambiente donde todos pueden hacer su mejor trabajo

La transición más difícil

Es común que engineering managers extrañen el feedback inmediato del código. El management es más ambiguo: podés hacer todo "bien" y que algo falle por factores externos.

Preguntas frecuentes

¿Cuánto tiempo lleva pasar de junior a senior?

No hay timeline fijo. He visto seniors sólidos con 3 años de experiencia y juniors eternos con 8 años. La diferencia está en la calidad de experiencia, no la cantidad de tiempo.

¿Es necesario hacer management para progresar?

No. El track técnico (senior → staff → principal) es válido y bien pagado. Elegí según tus fortalezas: ¿te energiza resolver problemas técnicos complejos o desarrollar personas?

¿Qué pasa si no me interesa el liderazgo?

Perfecto. Podés hacer carrera como individual contributor. Las mejores empresas tienen roles como "Staff Engineer" o "Principal Engineer" que son puramente técnicos y pagan igual o más que management.

La industria necesita tanto technical leaders como people managers. Lo importante es encontrar tu fit y no sentir que "tenés que" hacer management para progresar.