Dev&Ops

En este episodio hablamos de algo que muchos usamos todos los días… pero pocos entienden a fondo: la infraestructura detrás de un CI/CD pipeline.
¿Qué hay realmente detrás de un simple “runs-on: ubuntu-latest”? ¿Por qué existen los runners personalizados? ¿Cuándo necesitas cache, artifacts o un container registry propio?
Douglas explica el “esqueleto” de un pipeline moderno y cómo estos componentes impactan directamente en rendimiento, seguridad, escalabilidad y costos. Una conversación clave tanto para developers como para quienes trabajan en sistemas, SRE o DevOps.
🔍 En este episodio aprenderás:
Qué es un runner y por qué no siempre basta con el que te da la nube
Cuándo necesitas runners privados, efímeros o con Kubernetes
Cómo funciona el cache en CI/CD y por qué puede reducir builds de 40 a 6 minutos
Qué son los artifacts y por qué son clave para rollbacks
Cómo y por qué usar un container registry propio
Qué pedirle a tu equipo de operaciones cuando tu pipeline es lento
¡Únete a nuestra comunidad online! 👇
YouTube: https://www.youtube.com/@DevAndOpsPodcast ▶️
TikTok: https://www.tiktok.com/@devandops 🕺
Instagram: https://www.instagram.com/devandopspodcast/ 📸
Facebook: https://www.facebook.com/devandops 👍
Spotify: https://open.spotify.com/show/1MuMODYsE4xN6RhOcd8EaG 🎧
📑 Capítulos:
 (00:00) Introducción: infraestructura detrás del CI/CD
 (01:03) Estado actual y contexto del episodio
 (02:00) ¿Qué es realmente el esqueleto de un pipeline?
 (09:17) Runners: qué son y cómo funcionan
 (14:13) ¿Por qué separar runners de Jenkins o GitLab?
 (17:00) Casos reales para usar runners privados
 (20:39) Runners efímeros con Kubernetes
 (25:37) ¿Un runner puede ser un contenedor?
 (29:00) Cache en CI/CD: qué es y por qué es crítico
 (33:00) Cómo el cache acelera pipelines grandes
 (39:33) Artifacts: qué son y para qué sirven
 (45:14) Cache vs Artifacts: cuándo usar cada uno
 (51:00) Container Registry como parte del pipeline
 (55:00) Seguridad y tokens temporales
 (57:19) Reflexión final para developers y SREs
 (1:01:04) Cierre del episodio

¿Estamos ante una revolución real o una burbuja tecnológica más? En este episodio de Dev&Ops, Juan y Douglas analizan cómo la Inteligencia Artificial ha transformado el ciclo de vida del desarrollo de software desde el 2022 hasta el panorama actual de inicios de 2026. Exploramos la transición del "googleo" tradicional al uso de LLMs integrados en la terminal, y cómo esto ha impactado no solo la velocidad, sino también la salud mental y el perfil profesional de los desarrolladores.
En este episodio cubrimos:
- Cambio de Paradigma en el Flujo de Trabajo: De la búsqueda en Stack Overflow a la asistencia inmediata en el IDE y la terminal.
- Pair Programming con IA: Cómo utilizar el brainstorming y la planeación de tareas para que la IA actúe como un copiloto y no como un reemplazo del pensamiento crítico.
- La Realidad de las Alucinaciones: Por qué es vital mantener el escepticismo técnico y supervisar cada línea generada, evitando que la IA nos dé la razón erróneamente.
- Carga Cognitiva y Context Switching: El impacto de gestionar múltiples tareas aceleradas por IA y estrategias para recuperar la "sanidad mental".
- IA como Juez y Parte: El debate sobre el uso de agentes para generar código, crear unit tests y realizar code reviews de forma automatizada.
- Evolución del Perfil Profesional: Por qué el rol del programador está mutando hacia el de un supervisor de sistemas y qué habilidades (las bases) siguen siendo innegociables.
Únete a nuestras redes sociales:
YouTube: https://www.youtube.com/@DevAndOpsPodcast ▶️
TikTok: https://www.tiktok.com/@devandops 🕺
Instagram: https://www.instagram.com/devandopspodcast 📸
Facebook: https://www.facebook.com/devandops 👍
Spotify: https://open.spotify.com/show/1MuMODYsE4xN6RhOcd8EaG 🎧
📑 Chapters:
(00:00) Introducción: Reaprender las características de nuestro empleo 
(03:50) La gran comparación: ¿Es la IA el nuevo Internet? 
(10:45) El fin de "googlear": La integración de la IA en el flujo diario 
(16:20) Estrategias de Brainstorming y Pair Programming efectivo 
(30:10) El riesgo de la complacencia: Alucinaciones y validación de resultados 
(38:45) Impacto en la salud mental: Carga cognitiva y fatiga por multitarea 
(44:20) Gestión de infraestructura y Pull Requests masivos con agentes 
(54:15) El dilema ético y técnico: IA como juez y parte en el desarrollo 
(1:03:05) El futuro del perfil profesional y el mercado laboral en 2026
#devops #softwaredevelopment #ia #ingenieriadesoftware #productividad #saludmental #tecnologia #careerdevelopment #programming2026

En este episodio hablamos sobre comandos de Linux que son clave al trabajar con pipelines de CI/CD. Partiendo de la experiencia práctica en GitHub Actions, Jenkins y otros runners, conversamos sobre cómo los pipelines dependen casi siempre de una terminal Linux y cómo sacarle el máximo provecho.
Douglas y Juan recorren comandos fundamentales para interactuar con APIs, procesar texto, manejar JSON y YAML, trabajar con variables de entorno y sincronizar archivos de forma eficiente, siempre desde el contexto real de un pipeline. Un episodio especialmente útil para developers que quieren entender mejor qué pasa “detrás de escena” y para quienes trabajan en DevOps día a día.
🔍 En este episodio aprenderás:
Por qué la terminal Linux es la base de la mayoría de los CI/CD pipelines
Cómo usar curl para interactuar con APIs, webhooks y health checks
Para qué sirve awk al procesar outputs y logs en pipelines
Cómo jq y yq ayudan a trabajar con JSON y YAML
Qué es envsubst y cómo usar templates con variables de entorno
Por qué rsync es el comando favorito para despliegues y sincronización
¡Únete a nuestra comunidad online! 👇
YouTube: https://www.youtube.com/@DevAndOpsPodcast ▶️
TikTok: https://www.tiktok.com/@devandops 🕺
Instagram: https://www.instagram.com/devandopspodcast/ 📸
Facebook: https://www.facebook.com/devandops 👍
Spotify: https://open.spotify.com/show/1MuMODYsE4xN6RhOcd8EaG 🎧
📝 Capítulos:
(00:00) GitHub Actions y la adopción de CI/CD por developers
(00:50) Bienvenida al episodio 46
(01:52) Introducción al tema: comandos Linux para CI/CD
(06:36) Experiencia de Juan con pipelines y GitHub Actions
(09:19) Importancia del output y la información del pipeline
(13:08) curl: el navegador web en la terminal
(23:10) Diferencias entre curl y wget
(25:55) awk: procesando texto y columnas en pipelines
(35:20) Uso combinado de grep y awk
(37:45) jq y yq: trabajando con JSON y YAML
(46:30) envsubst: templates y variables de entorno
(59:47) rsync: sincronización eficiente de archivos
(1:10:51) Mensajes finales y cierre del episodio

¿Debes escribir tus queries a mano o dejar que una librería lo haga por ti? En este episodio, Juan y Douglas se sumergen en el eterno debate: ORM (Object-Relational Mapping) vs. SQL Nativo.
Analizamos las ventajas de abstracción y seguridad de los ORMs, frente al control total y el rendimiento que ofrece escribir SQL directo. Además, hablamos sobre:
El problema del rendimiento y las consultas N+1.
La falsa promesa de la "portabilidad" entre bases de datos.
Nuevas alternativas como los Query Builders (SQLC).
Por qué, elijas lo que elijas, los fundamentos de SQL son innegociables.
Si eres desarrollador o trabajas en infraestructura, este episodio te ayudará a decidir la mejor estrategia para tu próximo proyecto. ¡No olvides darle like y suscribirte para más charlas de tecnología!
¡Únete a nuestra comunidad online! 👇
YouTube: https://www.youtube.com/@DevAndOpsPodcast ▶️
TikTok: https://www.tiktok.com/@devandops 🕺
Instagram: https://www.instagram.com/devandopspodcast 📸
Facebook: https://www.facebook.com/devandops 👍
Spotify: https://open.spotify.com/show/1MuMODYsE4xN6RhOcd8EaG 🎧
Capítulos:
(00:00) Introducción: El gran debate del desarrollo
(02:17) ORM vs SQL: ¿Qué es cada uno?
(05:17) Ventajas de los ORM: Autocómpleto y Tipado
(10:30) El poder y control del SQL Nativo
(12:50) Store Procedures y Funciones en la base de datos
(15:10) Seguridad: Protegiéndonos de la Inyección SQL
(18:45) Migraciones y Observabilidad del código
(22:10) Logs y APM: Identificando queries lentos
(26:59) El mito de la portabilidad en las bases de datos
(31:00) El peligro del problema N+1 en ORMs
(35:55) ¿Combinar ambos mundos es la solución?
(38:15) La nueva era: Query Builders (SQLC)
(42:28) Conclusiones finales
#devops #desarrolloDeSoftware #sql #orm #basesDeDatos #programacion #backend #postgresql #mysql #rendimiento #queryBuilder #sqlc #inyeccionSql #apm #techPodcast

En este episodio analizamos ofertas laborales reales en el área de sistemas, DevOps y desarrollo para entender qué están buscando las empresas en 2026.
Desmitificamos la idea de que hay que saber todo (Kubernetes, IA, GitOps, Service Mesh, etc.) para conseguir trabajo y revisamos, punto por punto, requerimientos reales del mercado.
Hablamos de puestos como SRE, DevOps Engineer, Frontend Engineer y Backend Go, revisando qué es realmente indispensable, qué es “nice to have” y cómo interpretar correctamente las descripciones laborales para no auto-descartarse.
Un episodio ideal si estás buscando tu primer trabajo, cambiar de empleo o prepararte mejor para el mercado actual, ya sea remoto o presencial.
🔍 En este episodio aprenderás:
Qué piden realmente las empresas en ofertas IT en 2026
Cómo interpretar años de experiencia y requisitos “inflados”
Qué tecnologías siguen siendo clave en DevOps y desarrollo
La importancia del inglés, portfolios y experiencia demostrable
Por qué no necesitas saber “todo” para aplicar a un buen puesto
Diferencias entre puestos senior, mid y contractor
Qué tan relevante es hoy la inteligencia artificial en ofertas reales

¡Únete a nuestra comunidad online! 👇
YouTube: https://www.youtube.com/@DevAndOpsPodcast ▶️
TikTok: https://www.tiktok.com/@devandops 🕺
Instagram: https://www.instagram.com/devandopspodcast/ 📸
Facebook: https://www.facebook.com/devandops 👍
Spotify: https://open.spotify.com/show/1MuMODYsE4xN6RhOcd8EaG 🎧
📑 Capítulos:
(00:00) Mitos sobre conseguir trabajo en tecnología
(01:11) Bienvenida y métricas de la audiencia
(03:21) Agradecimiento a la comunidad internacional
(05:10) Objetivo del episodio: analizar ofertas reales
(07:11) Contexto del mercado laboral en 2026
(10:46) Aclaraciones sobre empresas y ofertas reales
(11:12) Oferta SRE: requisitos y realidad del puesto
(15:35) Años de experiencia vs experiencia real
(18:55) Kubernetes, AWS y expectativas reales
(22:55) Bash vs Python en automatización
(26:44) Observabilidad y monitoreo en la práctica
(29:40) Conclusiones del puesto SRE
(31:42) Puesto Senior Frontend Engineer (Field)
(36:06) Arquitectura frontend y rendimiento
(38:10) Importancia del code review
(42:04) Frontend moderno: React, Next.js y WordPress
(45:39) Portafolio y experiencia demostrable
(49:43) Puesto DevOps Engineer (Launchpad)
(55:33) Requisitos accesibles vs seniority
(59:11) Certificaciones, FinOps y DevSecOps
(1:00:49) Senior Go Backend Engineer (Job City)
(1:05:19) Cómo leer correctamente una oferta laboral
(1:09:41) Conclusiones sobre el mercado en 2026
(1:11:06) Recomendaciones finales para la audiencia