Presentación del curso DevOps, SRE y Platform Engineering

Producción está caída. Slack parece una tragaperras con notificaciones. Alguien pregunta si el problema es DNS. Otro dice que “en local funciona”. Jenkins está rojo, Kubernetes dice CrashLoopBackOff, Grafana parece un árbol de Navidad y tú tienes esa sensación tan concreta de estar delante de un panel de mandos de avión con una pegatina que dice: “no tocar salvo que sepas lo que haces”.

¿Es infraestructura? ¿Es networking? ¿Es el deploy? ¿Es la base de datos? ¿Es DNS? Sí, probablemente también es DNS. Bienvenido al tipo de caos que convierte “yo solo quería programar” en “ahora tengo opiniones fuertes sobre timeouts, logs y presupuestos de error”.

Bienvenido al curso DevOps, SRE y Platform Engineering: un curso completo y gratuito para aprender, desde cero, cómo se construyen, despliegan, observan y operan sistemas modernos. No desde el hype. No desde la diapositiva con nubes bonitas. Desde la realidad: Linux, terminal, redes, CI/CD, Docker, Kubernetes, Terraform, observability, SRE, incidentes, error budgets, Backstage e Internal Developer Platforms.

Por qué este curso importa en 2026

Durante años, “hacer DevOps” significó cosas muy distintas según la empresa: automatizar deployments, escribir scripts, apagar fuegos, llevar Kubernetes, mantener Jenkins, tocar Terraform, revisar dashboards, recibir alertas a las 3 de la mañana y, de vez en cuando, recordar que también existía la vida fuera de PagerDuty.

Aquí hay que decirlo claro: DevOps no es comprar herramientas. No haces DevOps porque tengas Jenkins, Docker y Kubernetes instalados, igual que no eres chef por tener tres sartenes y una freidora de aire. Ayuda, sí. Pero si no entiendes qué problema resuelve cada cosa, solo tienes más botones para pulsar cuando algo se rompe.

Y ese es el punto de este curso: construir el mapa completo.

Primero entenderás la base: Linux, terminal, procesos, logs, networking y Bash. Luego vendrán los pipelines, los contenedores, Kubernetes y Terraform. Después entraremos en observability, SRE, incident management, postmortems, chaos engineering, capacity planning y cost optimization. Y al final subiremos un nivel más: Platform Engineering, Golden Paths, Developer Experience, Backstage, service catalogs e Internal Developer Platforms.

El objetivo no es que memorices comandos como si fueran hechizos de un grimorio YAML. El objetivo es que entiendas por qué todo esto existe y cómo se conecta.

Qué hace diferente a este curso

Muchos cursos de DevOps fallan por el mismo motivo: saltan directamente a Kubernetes como quien empieza una casa por el tejado y luego se sorprende de que el baño esté en el aire.

Te enseñan a hacer kubectl apply, pero no te explican bien Linux. Te hablan de CI/CD, pero no de feedback loops. Te muestran Terraform, pero no el riesgo de convertir infraestructura en “copy-paste con estado remoto”. Te venden Platform Engineering como “pon Backstage y listo”.

Como funciona tener un mando universal con 47 botones y ninguno etiquetado: técnicamente controla la tele, pero cada intento de subir el volumen tiene un 20% de probabilidades de abrir Netflix, apagar el router o invocar un demonio menor de HDMI.

Este curso va por otro camino:

• Desde cero de verdad: empezamos con Linux y terminal porque toda la torre se apoya ahí. Si esa base está floja, Kubernetes no te va a salvar; solo va a generar errores con más YAML.
• DevOps → SRE → Platform Engineering: no son tres etiquetas para poner en LinkedIn. Son una evolución natural: automatizar entrega, gestionar fiabilidad y construir plataformas internas que reducen carga cognitiva.
• Principios antes que herramientas: aprenderás Jenkins, Docker, Kubernetes, Terraform, Prometheus, Grafana y Backstage, pero siempre como respuesta a un problema real.
• Producción como contexto: deployments, alertas, logs, rollback, incidentes, postmortems, SLOs y error budgets. Lo que importa cuando ya no estás en el tutorial feliz.
• Platform Engineering sin humo: una Internal Developer Platform no es “otro portal más”. Es producto interno para developers. Si no reduce fricción, es decoración corporativa con login.

Qué vas a aprender

El curso tiene 76 lecciones en 11 módulos, diseñado para llevarte desde cero hasta construir una plataforma interna completa:

1. Linux y terminal: filesystem, procesos, servicios, logs, Bash scripting y Git aplicado a infraestructura.
2. Networking fundamentals: DNS, HTTP, puertos, routing, firewalls y todo eso que nadie quiere mirar hasta que producción decide hacer teatro experimental.
3. CI con Jenkins: pipelines, builds, tests, artefactos y automatización de entrega.
4. Docker: contenedores, imágenes, Compose, registry y buenas prácticas. Si quieres profundizar antes, el curso Domina Docker desde cero encaja como antesala perfecta.
5. Kubernetes: pods, deployments, services, ingress, config, secrets, Helm y operación básica de clusters.
6. Terraform: infraestructura como código, módulos, estados, entornos y provisioning cloud.
7. Observability: métricas, logs, trazas, Prometheus, Grafana, alertas, SLOs y dashboards útiles, no cuadros de colores para fingir control.
8. SRE: error budgets, incident management, postmortems, chaos engineering, capacity planning, on-call y cultura de fiabilidad.
9. Platform Engineering: Golden Paths, Developer Experience, self-service, estándares, guardrails y métricas de plataforma.
10. Internal Developer Platforms: Backstage, service catalog, TechDocs, templates, plugins, integraciones y tooling interno.
11. Proyecto final: diseñar e implementar una IDP realista para una empresa ficticia con 150 engineers, 80+ microservicios y bastante dolor acumulado. O sea, un martes normal en software.

La línea que une todo es importante: no vamos a estudiar herramientas sueltas. Vamos a construir criterio operativo. Ese criterio que te permite mirar un incidente y decir: “no sé aún qué pasa, pero sé por dónde empezar”. Eso vale oro.

¿Necesito conocimientos previos?

No. El roadmap está pensado para principiantes absolutos, incluso si no has tocado Linux ni infraestructura antes.

Lo que sí ayuda:

• Saber moverte mínimamente con Git. Si no, empieza por Domina Git desde cero, porque infraestructura sin Git es como hacer cirugía con guantes de cocina.
• Tener curiosidad por cómo funcionan los sistemas cuando salen de tu portátil.
• Aceptar que la terminal será parte de tu vida. No te agobies: al principio parece una cueva oscura; luego descubres que tenía luz, atajos y menos pop-ups que cualquier GUI con Electron.
• Ganas de entender, no solo de copiar comandos.

Si ya vienes de backend, Docker, Linux o cloud, avanzarás más rápido en algunos módulos. Si empiezas desde cero, el curso está diseñado precisamente para que no tengas que fingir que entiendes qué es un socket mientras asientes con cara seria.

Una advertencia honesta

DevOps, SRE y Platform Engineering son disciplinas enormes. No se aprenden en una tarde. Y quien te prometa “domina Kubernetes en 2 horas” probablemente también vende cursos de trading con Lamborghinis alquilados.

Este curso va a pedirte práctica. Vas a tocar terminal, romper cosas en entornos controlados, leer logs, escribir scripts, desplegar servicios, mirar métricas, diseñar runbooks y pensar en trade-offs. Porque operar software no consiste en que todo vaya bien; consiste en estar preparado para cuando no va bien.

Y aquí se pone interesante: el objetivo no es que nunca haya incidentes. Eso es fantasía. El objetivo es construir sistemas que fallen de forma entendible, recuperable y cada vez menos dramática. Pasar de “¿quién ha tocado producción?” a “tenemos alerta, runbook, rollback y postmortem sin culpa”.

Eso es madurez técnica.

De apagar fuegos a construir plataformas

La evolución del curso es deliberada.

DevOps te enseña a automatizar y conectar desarrollo con operaciones. SRE te enseña a gestionar la fiabilidad con ingeniería, datos y límites explícitos. Platform Engineering te enseña a convertir todo ese conocimiento en una plataforma que otros equipos puedan usar sin abrir cinco tickets y sacrificar una cabra a la VPN corporativa.

Al final del recorrido, no solo sabrás desplegar una aplicación. Sabrás diseñar un camino para que otros developers desplieguen mejor, más rápido y con menos sustos. Ese cambio de mentalidad es enorme: de “yo opero sistemas” a “yo construyo la carretera por la que otros equipos entregan software”.

Y cuando esa carretera está bien hecha, nadie piensa en ella. Como los buenos ascensores, los buenos DNS y las buenas sillas de oficina: solo se notan cuando fallan. Spoiler: DNS se nota mucho.

---

Primera lección disponible el 3 de julio: “Introducción al mundo DevOps”.

¡Nunca dejes de programar!