Navegando la Industria Tech: De Ingeniero Junior a Senior

He mentoreado a docenas de ingenieros de junior a senior, y he hecho este viaje yo mismo. El camino no siempre es obvio, pero ciertos patrones predicen consistentemente el éxito. Esta guía comparte lo que he aprendido.

Entendiendo los Niveles

Los niveles de carrera no se tratan de años—se tratan de alcance e impacto.

┌─────────────────────────────────────────────────────────────────┐
│                    Escalera de Carrera en Ingeniería             │
├─────────────────────────────────────────────────────────────────┤
│                                                                  │
│  Ingeniero Junior (0-2 años)                                     │
│  └─ Alcance: Tareas → Completar trabajo asignado con guía        │
│                                                                  │
│  Ingeniero Mid-Level (2-5 años)                                  │
│  └─ Alcance: Features → Ser dueño de features de punta a punta   │
│                                                                  │
│  Ingeniero Senior (5-8+ años)                                    │
│  └─ Alcance: Sistemas → Diseñar sistemas, mentorear, establecer  │
│                         estándares                               │
│                                                                  │
│  Staff Engineer (8+ años)                                        │
│  └─ Alcance: Organización → Influir dirección técnica ampliamente│
│                                                                  │
│  Principal/Distinguished (10+ años)                              │
│  └─ Alcance: Industria → Moldear estrategia de empresa e industria│
│                                                                  │
└─────────────────────────────────────────────────────────────────┘

Fase 1: Junior a Mid-Level

Esta fase se trata de construir tu fundamento técnico y aprender a ser confiable.

Competencias Clave a Desarrollar

1. Domina Tu Stack Principal

Escoge un stack y profundiza. Deberías poder:

• Depurar problemas sin Stack Overflow
• Explicar cómo funciona el framework internamente
• Tomar decisiones informadas sobre patrones y librerías

# Enfoque junior: Copiar y pegar patrón
def get_user(user_id):
    try:
        return db.query(User).filter(User.id == user_id).first()
    except Exception as e:
        print(f"Error: {e}")
        return None
 
# Enfoque mid-level: Manejo intencional de errores, tipos, logging
from typing import Optional
import logging
 
logger = logging.getLogger(__name__)
 
def get_user(user_id: int) -> Optional[User]:
    """Obtener usuario por ID con manejo apropiado de errores."""
    try:
        user = db.query(User).filter(User.id == user_id).first()
        if not user:
            logger.info(f"Usuario {user_id} no encontrado")
        return user
    except DatabaseError as e:
        logger.error(f"Error de base de datos obteniendo usuario {user_id}: {e}")
        raise

2. Aprende a Estimar

La estimación es una habilidad. Rastrea tus estimaciones vs. reales:

Con el tiempo, te calibrarás. Los ingenieros senior son buenos estimando porque se han equivocado suficientes veces para saber dónde se esconde la complejidad.

3. Escribe Código Que Otros Puedan Leer

El código se lee 10x más de lo que se escribe. Optimiza para el lector:

// Difícil de entender
const f = (a: any[]) => a.filter(x => x.s === 'a' && x.d > Date.now() - 86400000);
 
// Intención clara
const MILLISECONDS_PER_DAY = 24 * 60 * 60 * 1000;
 
interface Task {
  status: 'active' | 'completed' | 'archived';
  dueDate: number;
}
 
function getRecentActiveTasks(tasks: Task[]): Task[] {
  const oneDayAgo = Date.now() - MILLISECONDS_PER_DAY;
  return tasks.filter(task =>
    task.status === 'active' &&
    task.dueDate > oneDayAgo
  );
}

Comportamientos Que Aceleran el Crecimiento

1. Haz preguntas públicamente - Tu confusión es compartida por otros. Preguntas en canales de equipo ayudan a todos.

2. Escribe documentación - Documenta lo que te confundió. Futuros compañeros te lo agradecerán.

3. Revisa código activamente - Aunque no puedas aprobar, lee PRs y haz preguntas. Aprenderás patrones más rápido.

4. Ofrécete para el trabajo feo - Triaje de bugs, deuda técnica, documentación. Estos enseñan más que proyectos greenfield.

Fase 2: Mid a Senior

Esta es la transición más difícil. La habilidad técnica se vuelve lo básico; el impacto se convierte en el diferenciador.

El Cambio de Mentalidad Senior

Según el trabajo influyente de Larson sobre ingeniería staff (Larson, 2021), los ingenieros senior operan diferente:

Habilidades Multiplicadoras

1. Toma de Decisiones Técnicas

Documenta decisiones sistemáticamente:

# ADR-001: Eligiendo una Cola de Mensajes
 
## Contexto
Necesitamos procesamiento asíncrono para notificaciones por email. Actualmente manejamos 10k/día, esperamos 100k/día en 6 meses.
 
## Opciones Consideradas
 
### Opción A: Redis Pub/Sub
- Pros: Ya está en el stack, simple
- Contras: Sin persistencia, escalado limitado
 
### Opción B: RabbitMQ
- Pros: Maduro, buena persistencia, ruteo
- Contras: Overhead operacional, nueva infraestructura
 
### Opción C: AWS SQS
- Pros: Administrado, escala automáticamente, barato
- Contras: Vendor lock-in, límite de mensaje 256KB
 
## Decisión
AWS SQS. La simplicidad operacional supera las preocupaciones de lock-in para nuestra escala.
 
## Consecuencias
- Necesitamos diseñar para el límite de 256KB (usar S3 para payloads grandes)
- El equipo necesita capacitación en SQS
- Se requiere configuración de monitoreo

2. Pensamiento de Diseño de Sistemas

Piensa en términos de sistemas, no features:

┌─────────────────────────────────────────────────────────────┐
│                 Checklist de Diseño de Sistemas              │
├─────────────────────────────────────────────────────────────┤
│                                                              │
│  □ ¿Cuáles son los requisitos (funcionales + no funcionales)?│
│  □ ¿Cuáles son los modos de falla?                           │
│  □ ¿Cómo escala?                                             │
│  □ ¿Cómo lo monitoreamos?                                    │
│  □ ¿Cómo desplegamos y hacemos rollback?                     │
│  □ ¿Cuál es el camino de migración desde el estado actual?   │
│  □ ¿Quién mantendrá esto en 2 años?                          │
│                                                              │
└─────────────────────────────────────────────────────────────┘

3. Mentoría

Tu impacto se multiplica a través de otros. Patrones efectivos de mentoría:

• Code review como enseñanza - Explica el "por qué," no solo el "qué"
• Pair programming - 30 minutos pareando > 2 horas de review asíncrono
• Horas de oficina - Tiempo dedicado para preguntas reduce interrupciones
• Documentación - Escribe la guía que desearías haber tenido

Construyendo Credibilidad

Los ingenieros senior son confiados. La confianza se construye a través de:

1. Entregar consistentemente - Cumple compromisos. Si no puedes, comunica temprano.

2. Ser dueño de los fallos - "Rompí producción" construye más confianza que excusas.

3. Mantener la calma en crisis - Sé la persona que piensa claramente cuando las cosas se rompen.

4. Tener opiniones, sostenidas con ligereza - Perspectivas técnicas fuertes, pero dispuesto a estar equivocado.

Fase 3: Senior a Staff y Más Allá

Los roles Staff+ se tratan de impacto organizacional. La habilidad técnica es necesaria pero insuficiente.

Trabajando a Escala

Los ingenieros staff piensan sobre:

• Estrategia técnica - ¿Dónde debería estar la arquitectura en 2 años?
• Problemas cross-team - Problemas que abarcan múltiples equipos
• Cultura técnica - ¿Cómo toma decisiones la organización?
• Desarrollo de talento - Construyendo la próxima generación de líderes

El Trabajo Pegamento

El concepto de Tanya Reilly de "glue work" (Reilly, 2019) describe el trabajo esencial pero frecuentemente invisible que mantiene unidos a los equipos:

• Escribir documentación que previene preguntas repetidas
• Construir herramientas que ahorran tiempo a todos
• Facilitar discusiones que llevan a decisiones
• Identificar y abordar problemas de proceso

Estrategia de Carrera

Eligiendo Empresas

Diferentes empresas ofrecen diferente crecimiento:

Cuándo Irse

Considera moverte cuando:

• Has dejado de aprender
• Tu impacto está limitado por la organización
• Existen mejores oportunidades (y le has dado una oportunidad justa a tu rol actual)

Quédate cuando:

• Todavía estás aprendiendo
• Hay un camino claro hacia más alcance
• No has explorado completamente lo que es posible

Conclusión

El camino de junior a senior no es una línea recta—es una serie de transiciones:

1. Junior → Mid: Construir competencia técnica y confiabilidad
2. Mid → Senior: Expandir alcance de tareas a sistemas
3. Senior → Staff: Mover de impacto de equipo a impacto organizacional

Cada transición requiere soltar lo que te hizo exitoso antes. El mejor código que puedes escribir es el código que no escribes porque encontraste una mejor solución al problema.

Enfócate en el impacto. Todo lo demás sigue.

Referencias

Larson, W. (2021). Staff Engineer: Leadership beyond the management track. https://staffeng.com/book

Reilly, T. (2019). Being glue. No Idea Blog. https://noidea.dog/glue

Fournier, C. (2017). The manager's path: A guide for tech leaders navigating growth and change. O'Reilly Media.

Google. (2024). Software engineering at Google: Lessons learned from programming over time. O'Reilly Media. https://abseil.io/resources/swe-book

¿Quieres discutir tu trayectoria profesional? Contáctame para conversaciones de mentoría.