Dev&Ops

En este episodio de Dev&Ops hablamos sobre cómo reducir costos al correr Kubernetes en AWS, especialmente usando EKS. Douglas comparte consejos prácticos basados en experiencia real operando infraestructura en Kubernetes, desde optimización de aplicaciones hasta estrategias avanzadas con hardware, tráfico, Spot Instances, Saving Plans y Karpenter.El episodio explica por qué Kubernetes puede elevar la factura en AWS si no se planifica correctamente, qué elementos terminan generando costos y cómo aplicar buenas prácticas para controlar mejor el consumo de recursos, el tráfico entre Availability Zones y el uso de nodos.También se aborda una configuración práctica usando nodos on demand para servicios críticos, Saving Plans para reducir costos base, y Karpenter para aprovisionar dinámicamente Spot Instances con fallback a instancias on demand cuando sea necesario. 🔍 En este episodio aprenderás: Por qué EKS puede incrementar significativamente la factura en AWS  Cómo optimizar aplicaciones para consumir menos CPU, memoria y recursos  La importancia de definir límites en pods, réplicas y nodos  Cómo reducir costos controlando tráfico, requests y ancho de banda  Por qué evitar tráfico innecesario entre Availability Zones  Cómo usar Saving Plans y Spot Instances para ahorrar en nodos  Cómo Karpenter ayuda a escalar y consolidar recursos de forma eficiente📑 Capítulos:(00:00) Configuración actual con Kubernetes, Karpenter y Spot Instances(01:13) Bienvenida al episodio 61 de Dev&Ops(02:20) Tema del episodio: optimizar costos corriendo Kubernetes en AWS(04:10) Por qué EKS puede aumentar la factura en AWS(06:30) Aclaraciones: consejos generales y enfoque en AWS EKS(08:35) Consejo 1: optimiza tu aplicación para consumir menos recursos(11:20) Consejo 2: asegúrate de que tu aplicación sea cloud native(15:05) Consejo 3: define límites para pods, réplicas y nodos(18:35) Control de requests, caché y reducción de carga en Kubernetes(20:53) Consejo 4: usa Ingress con Application Load Balancer(23:40) AWS Load Balancer Controller, ALB y WAF(26:20) Consejo 5: evita tráfico innecesario entre Availability Zones(29:10) Qué son las Availability Zones y por qué el tráfico cuesta dinero(32:25) Ejemplo práctico: mantener requests dentro de la misma Availability Zone(36:10) Estrategias para controlar tráfico interno en Kubernetes(38:30) Service Mesh como alternativa para enrutar tráfico local(41:00) Consejos de hardware para reducir costos en EKS(42:10) Consejo 6: implementa AWS Saving Plans(45:40) Cómo funcionan los compromisos de gasto en Saving Plans(48:10) Aplicar Saving Plans al consumo base de nodos on demand(49:05) Consejo 7: implementa Spot Instances(51:20) Cómo combinar nodos on demand con Spot Instances(52:35) Consejo 8: implementa Karpenter(53:45) Cómo Karpenter escala, consolida y optimiza nodos(54:30) Configuración práctica: node pool fijo, Saving Plans y Spot Instances(55:15) Cierre y recomendaciones finales

¿Estás pensando en migrar a microservicios o ya estás sufriendo las consecuencias? En este episodio de Dev&Ops, desglosamos lo que NO te cuentan los tutoriales sobre la arquitectura de microservicios. Desde la explosión de la complejidad operativa y los fallos en cascada, hasta el desafío de la consistencia eventual y la gestión de bases de datos descentralizadas. Analizamos cómo esta arquitectura puede amplificar los problemas culturales de una empresa (como la falta de tests o code reviews deficientes) y debatimos la eterna batalla entre Monorepos vs. Multi-repos. Si eres desarrollador, arquitecto o líder técnico, este video te dará la perspectiva real basada en experiencia para evitar que tu sistema se convierta en un caos inmanejable.Capítulos:(00:00) - Introducción: Microservicios y cultura empresarial(00:45) - La explosión de la complejidad operativa(02:30) - Fallos de comunicación y el efecto cascada(04:00) - Gestión de datos: Bases de datos descentralizadas(05:15) - El desafío de la Consistencia Eventual (Eventual Consistency)(06:45) - El dolor de cabeza de las zonas horarias y la sincronización(08:00) - Unit Tests vs. Integration Tests en microservicios(10:30) - Cómo los microservicios amplifican la cultura (buena o mala)(12:00) - Organización de código: Monorepos vs. Múltiples Repos(13:45) - Estrategias de Observabilidad y Logs efectivos(15:30) - Event-Driven Architecture: Ventajas y riesgos(17:15) - La importancia crítica de los Estándares Técnicos(19:00) - Conclusiones y cierre#devops #microservicios #softwarearchitecture #systemdesign #backend #monorepo #eventdriven #programacion #podcastdetecnologia

En este episodio analizamos si Linux finalmente puede entrar a competir en el mercado de escritorio frente a Windows y MacOS. A partir de experiencias reales y noticias recientes, exploramos cómo ha evolucionado Linux en usabilidad y qué factores están impulsando su adopción fuera del mundo de servidores.Hablamos del impacto de decisiones como la migración del gobierno de Francia hacia Linux, el crecimiento del gaming en este sistema operativo y el rol que está jugando la inteligencia artificial en cambiar las reglas del juego.También discutimos los retos reales: compatibilidad, drivers, costos de migración y por qué, a pesar del progreso, Linux aún no compite directamente en desktop… al menos por ahora.🔍 En este episodio aprenderás: Por qué Linux domina servidores pero sigue rezagado en desktop  Cómo la usabilidad de Linux ha cambiado en los últimos años  El impacto de la migración del gobierno de Francia a Linux  Por qué el gaming en Linux está creciendo  Los verdaderos costos de migrar de Windows a Linux en empresas  Cómo la inteligencia artificial podría hacer irrelevante el sistema operativo  Si Linux realmente tiene futuro en el escritorio 📑  Capítulos: (00:00) Introducción y contexto del episodio (02:10) Estado actual de Linux en desktop (05:30) Evolución de la usabilidad en Linux (09:00) Noticia: Migración del gobierno de Francia (13:30) Soberanía digital y Big Tech (17:30) Noticia: Crecimiento del gaming en Linux (21:30) Problemas de rendimiento en Windows (25:00) ¿Está Linux entrando en la pelea? (28:30) Adopción en empresas: costos y retos (32:30) Gaming en Linux: limitaciones actuales (35:30) Impacto de la inteligencia artificial en sistemas operativos (38:00) Reflexión final y cierre

¡Hola, comunidad Dev&Ops! 👋 En este episodio nos metemos de lleno en un debate que todo ingeniero ha tenido en algún momento ¿Realmente funcionan las metodologías ágiles en operaciones?Douglas nos cuenta su experiencia (y frustración) al intentar encajar guardias impredecibles (on-call) dentro de Sprints de 80 horas, mientras Juan nos da su perspectiva desde el lado del desarrollo. Hablamos sobre el estrés de las alertas, la odisea de estimar tiempos, la importancia de tener empatía con los Project Managers (¡que a veces los tiran a los leones! 🦁) y por qué nuestra madurez profesional es la clave para que cualquier proceso funcione, nos guste o no.¿Eres team Sprints o prefieres otra forma de organizarte? ¿Te cuesta loguear tus horas? ¡Queremos leer tu opinión y tus anécdotas en los comentarios! 👇 No olvides suscribirte para más pláticas honestas sobre el mundo tecnológico.Nuestras redes socialesYouTube: 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) Bienvenida y las batallas de hardware de Juan(02:33) ¿Por qué la cultura DevOps es nuestro pan de cada día?(05:45) Guardias y On-Call: Cuando las emergencias rompen tu agenda(08:49) El choque: Implementando Sprints en equipos operativos(12:18) Diferentes sabores de Sprints: Desarrollo vs Infraestructura(16:54) El arte (y el caos) de estimar horas de trabajo(22:31) Berrinches vs Profesionalismo: Nuestra actitud cuenta(28:41) Cómo aportar soluciones sin ser la "piedra de tropiezo"(34:44) La rebelión de los tickets: ¿Por qué odiamos loguear tiempo?(43:23) Piedad para los Project Managers: Empatía en el equipo(48:17) El orden es necesario: Responsabilidades de gerentes e ingenieros(54:02) Conclusión: Somos profesionales, hagamos que funcione#devops #agile #oncall #sprints #scrum #infraestructura #desarrollo #tecnologia #culturaorganizacional #podcasttecnologico #programacion #ingenieria

Kubernetes se ha convertido en el estándar para orquestación de contenedores, pero no siempre es la solución correcta para todos los escenarios. En este episodio analizamos las principales consideraciones que debes tener en cuenta antes de implementarlo en tu empresa o proyecto.Hablamos desde la complejidad inherente de Kubernetes, hasta errores comunes como sobreingeniería, falta de automatización o ausencia de observabilidad. También discutimos alternativas como Docker Swarm y cuándo realmente vale la pena dar el salto a Kubernetes.Si estás evaluando migrar a contenedores o ya decidiste usar Kubernetes, este episodio te ayudará a evitar dolores de cabeza y tomar decisiones más informadas.🔍 En este episodio aprenderás: Cómo validar si realmente necesitas Kubernetes o estás forzando su uso  Qué complejidades introduce Kubernetes incluso para aplicaciones simples  Por qué no debes implementar todas las herramientas desde el inicio  La importancia de automatizar la infraestructura desde el día uno  Cómo manejar despliegues con Helm o Customize de forma escalable  Por qué el monitoreo y la observabilidad son esenciales desde el comienzo 📑 Capítulos: (00:00) Introducción al episodio y contexto (02:26) Consideraciones antes de implementar Kubernetes (03:36) Kubernetes vs Docker en producción (04:39) Por qué muchas empresas eligen Kubernetes (06:50) Complejidad de Kubernetes para apps simples (08:59) Alternativa: Docker Swarm (10:12) Reevaluar decisiones tecnológicas (15:15) No implementar todo desde el inicio (18:26) Service Mesh y herramientas avanzadas (20:30) GitOps: ¿cuándo sí y cuándo no? (29:57) Importancia del tiempo y el enfoque incremental (32:14) Automatización con Infrastructure as Code (42:19) Uso de Helm y manejo de manifiestos (51:28) Riesgos y complejidad en Kubernetes (55:12) Monitoreo y observabilidad desde el inicio (56:54) Experiencia práctica y dificultades sin observabilidad (59:32) Cierre y conclusiones

¿Crees que programar con IA es solo escribir prompts y copiar código? La realidad es muy distinta. En este episodio, Juan nos revela la "verdad" detrás de un flujo de trabajo profesional en 2026, donde el autocompletado ha quedado obsoleto para dar paso a los flujos agénticos y el "Vibe Coding". No se trata de magia, sino de estrategia. Descubre los 10 consejos prácticos basados en 10 años de experiencia en la industria para dejar de escribir código línea por línea y empezar a dirigir la arquitectura de tus sistemas, asegurando que el resultado sea escalable, mantenible y, sobre todo, profesional.En este episodio aprenderás:La verdad sobre los patrones de diseño en la era de la IA.Por qué descargar "skills" genéricos es un error y cómo crear los tuyos.El uso real de AGENTS.md y PRDs para evitar que la IA alucine.La técnica de reducir el scope para sobrevivir a los Code Reviews.Cómo usar el modo "Planning" como una sesión de Rubber Ducking avanzada.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 🎧Capítulos:(00:00) Introducción y contexto: Programando en 2026(02:54) De GitHub Copilot a los flujos agénticos(05:09) ¿Cuándo usar IA y cuándo escribir código a mano?(06:39) Consejo 1: La importancia de los Patrones de Diseño y Clean Architecture(08:59) Consejo 2: Definir estándares y Naming Conventions(10:54) Consejo 3: Por qué debes escribir tus propios "Skills" (y no descargarlos)(14:19) Consejo 4: Maximizando el uso de AGENTS.md(16:29) Consejo 5: Spec-Driven Development y la creación de PRDs(18:49) Consejo 6: Reducir el scope para mejorar la mantenibilidad y el PR(22:09) Consejos 7 y 8: Tratar a la IA como un humano y el apoyo visual(24:49) Consejo 9: Planificación, iteración y Rubber Ducking con la IA(27:39) Consejo 10: La regla de oro: Revisar y evaluar siempre el resultado(29:59) Reflexiones finales: La IA no es magia, es preparación#ia #devops #inteligenciaartificial #programacion #softwareengineering #aiagents #productivity #cleancode #vibeCoding #systemDesign

¿El Tech Lead es solo un Senior con un título más bonito o realmente cambia su función? En este episodio, Juan y Douglas desglosan la figura del Lead de Tecnología: desde la diferencia crucial entre gestionar personas (Engineering Manager) y gestionar el stack técnico, hasta por qué las empresas pequeñas también necesitan uno para evitar el caos. Si quieres escalar en tu carrera técnica sin despegarte del código, este episodio es para ti.Lo que aprenderás hoy:La diferencia entre Tech Lead, Staff Engineer y Engineering Manager.Por qué el Tech Lead es el "dueño" del estándar técnico y no necesariamente el jefe administrativo.Habilidades clave: del troubleshooting experto a la evangelización y documentación.El modelo de Habilidades en T: profundidad en tu área y visión general del flujo (DNS, DB, Infra).Consejos prácticos para Juniors y Seniors que aspiran a liderar equipos.¡Únete a nuestra comunidad y no te pierdas nada!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: Tech Leads en todas las disciplinas(01:26) Bienvenidos a Dev&Ops: La importancia de compartir experiencias(02:41) El reto de definir qué es un Tech Lead según la empresa(04:00) El estándar de la industria vs. la realidad de las startups(07:30) ¿Seguimos copiando lo que hacen las FAANG (Meta, Google, Netflix)?(10:13) Nuevos roles: La IA y los puestos emergentes (LLM Operators)(12:00) Definición formal: ¿Qué dice Indeed sobre el Tech Lead?(14:48) Especializaciones: Tech Leads de Frontend, Backend y SRE(16:34) "¿Suena caro?": Por qué un Tech Lead te ahorra dinero a largo plazo(18:20) El Tech Lead como dueño del Stack y los estándares técnicos(20:30) Diferencia entre liderazgo técnico y gestión administrativa(23:10) ¿Debe un Tech Lead encargarse de las contrataciones?(26:30) Habilidades blandas: El fit cultural más allá del código(30:22) Tech Lead vs. Staff Engineer vs. Engineering Manager(37:50) Estructuras de equipo: ¿Cuántos leads necesitas según tu tamaño?(41:00) Evitando el caos: La importancia de la armonía técnica(44:23) Hoja de ruta: Habilidades para ser considerado un Tech Lead(47:44) La importancia del Research y entender el negocio(50:55) De experto a mentor: Documentación y evangelización técnica(56:23) Conclusión y consejos finales para tu carrera#devops #techlead #programacion #ingenieriadesoftware #staffengineer #crecimientoprofesional #tecnologia #systemdesign #podcasttecnologia #desarrolloweb

En este episodio hablamos a fondo sobre una de las preguntas más comunes hoy en día en inteligencia artificial: ¿es mejor usar modelos en la nube o correr IA en local?Compartimos experiencias reales probando modelos locales, los retos de hardware, costos ocultos, rendimiento y qué tan viable es realmente para el día a día. También exploramos casos prácticos donde sí tiene sentido usar IA en local y cuándo definitivamente no vale la pena.Si estás considerando montar tu propio entorno de IA o quieres optimizar costos, este episodio te va a dar claridad basada en experiencia real, no en “venta de humo”.🔍 En este episodio aprenderás: Qué es realmente la IA en local y cómo funciona  Diferencia entre modelos “open source” y “open weights”  Limitaciones reales de hardware (RAM, VRAM, contexto)  Cuándo sí tiene sentido usar modelos locales  Por qué la nube sigue siendo la mejor opción en muchos casos  Casos prácticos donde modelos pequeños funcionan muy bien  Cómo balancear costo, rendimiento y tiempo en tu workflow 📑 Capítulos: (00:00) Introducción y contexto del episodio (02:00) Nuevo integrante en la familia y regreso al podcast (04:30) Tema del episodio: IA en local vs en la nube (07:30) ¿Qué es la IA en local? (10:30) Open source vs open weights (14:00) Evolución de modelos (Llama, Qwen, etc.) (18:30) Limitaciones reales del hardware (22:00) Quantization explicado (26:30) Experimentos en hardware limitado (30:00) Casos de uso prácticos con modelos pequeños (35:30) Debate: IA local vs nube (42:00) Costos, planes y modelos en la nube (48:00) Problemas reales de rendimiento en local (52:00) Privacidad: mitos y riesgos (56:30) Casos donde sí vale la pena IA local (01:02:00) Conclusiones y recomendaciones (01:10:00) Cierre del episodio

En este episodio hablamos de uno de los temas más mal entendidos al trabajar con contenedores: por qué “Docker rompe producción”… cuando en realidad el problema es cómo lo operamos.A partir de experiencias reales migrando de VMs a contenedores, exploramos errores comunes que suelen pasar desapercibidos en desarrollo pero explotan en producción. Desde tratar contenedores como máquinas virtuales hasta no definir límites de recursos, usar latest o construir imágenes gigantes.También abordamos errores de “día 2” como manejo de logs, secretos, health checks y seguridad, que pueden tumbar sistemas completos si no se manejan correctamente.🔍 En este episodio aprenderás:Por qué los contenedores no son el problema, sino su operación El error de tratar contenedores como VMs (y cómo cambiar esa mentalidad) Cómo evitar caídas por falta de límites de CPU y memoria Por qué nunca deberías usar latest en producción Cómo optimizar imágenes Docker para mejorar performance y despliegues Errores comunes en logs, secretos y health checks en entornos productivos 📑 Capítulos: (00:00) Introducción y contexto del episodio (02:05) ¿Los contenedores realmente rompen producción? (05:10) Error #1: Tratar contenedores como VMs (pet vs cattle) (12:50) Error #2: No definir límites de recursos (19:40) Error #3: Usar el tag latest en producción (25:30) Error #4: Imágenes Docker pesadas (32:20) Errores de fase 2: logs, secretos, seguridad y health checks (39:30) Conclusiones y recomendaciones finales

La inteligencia artificial se ha robado la atención de toda la industria tecnológica, pero eso no significa que herramientas clave como Docker hayan desaparecido del flujo de trabajo de desarrollo y operaciones. En este episodio hablamos sobre cómo Docker Desktop sigue siendo una pieza fundamental en el desarrollo moderno, incluso en plena era de los agentes y los LLMs. Exploramos cómo los equipos de desarrollo y DevOps pueden aprovechar Docker Desktop no solo para ambientes de desarrollo tradicionales, sino también para nuevos flujos de trabajo relacionados con inteligencia artificial.En particular, analizamos dos funcionalidades interesantes que pueden integrarse fácilmente en el entorno local: Docker Model Runner para ejecutar modelos LLM locales y las herramientas de Docker para correr MCP Servers, permitiendo conectar aplicaciones de IA con servicios externos de forma más segura y estandarizada.Si ya utilizas contenedores en tu flujo de desarrollo, estas capacidades podrían ayudarte a simplificar la integración de IA en tu stack sin añadir más herramientas externas.🔍 En este episodio aprenderás:Por qué Docker dejó de ser un “buzzword” pero sigue siendo clave en DevOpsCómo Docker Desktop sigue facilitando ambientes de desarrollo locales con contenedoresQué es Docker Model Runner y cómo permite correr LLMs localesCómo interactuar con modelos locales usando APIs tipo OpenAI u OllamaQué es Model Context Protocol (MCP) y por qué es importante para aplicaciones de IACómo Docker Desktop facilita ejecutar MCP Servers de forma aislada y seguraCuándo tiene sentido usar Docker Desktop en flujos de trabajo con inteligencia artificial📑 Capítulos:(00:00) Introducción: IA, buzzwords y el rol actual de Docker (01:45) ¿Por qué Docker dejó de ser un buzzword? (04:20) Docker Desktop en los flujos de desarrollo modernos (07:30) Ambientes de desarrollo locales con contenedores (10:10) Kubernetes local dentro de Docker Desktop (13:00) Cómo la IA está cambiando el trabajo de desarrollo y operaciones (16:20) Primer enfoque: correr modelos LLM locales (19:10) Docker Model Runner: cómo funciona (22:40) APIs compatibles con OpenAI y Ollama (25:00) Segundo enfoque: qué es MCP (Model Context Protocol) (27:20) Problemas comunes al ejecutar MCP servers (29:40) Docker MCP Toolkit y MCP Catalog (31:50) Docker MCP Gateway y orquestación de MCP servers (33:10) Reflexión final: cuándo considerar Docker Desktop en la era de la IA

¡Bienvenidos a un nuevo episodio experimental de Dev&Ops! 🎉 Esta semana, Juan y Douglas salen un poco de la rutina y se sientan a reaccionar a tres artículos tecnológicos que están dando mucho de qué hablar en la industria.¿Alguna vez has considerado reemplazar tus scripts de Bash con Python? Analizamos los pros y contras de la portabilidad tanto en entornos locales como en servidores de producción. Luego, entramos en un debate picante: ¿Deberíamos dejar de usar Redis, MongoDB y Pinecone para meter TODO dentro de PostgreSQL?  Hablamos sobre la centralización, la robustez de los sistemas complejos y el temido "Single Point of Failure".Para cerrar, exploramos el fascinante pero doloroso mundo de las aplicaciones "Local First". ¿Por qué no son el estándar de la industria si prometen tanta seguridad y control? Profundizamos en la pesadilla que es la sincronización de datos, abordando conceptos complejos como los Relojes Lógicos Híbridos (HLC)  y los Conflict-free Replicated Data Types (CRDTs).¡No olvides dejarnos en los comentarios qué opinas tú! ¿Te quedarías solo con Postgres? ¿Eres team Bash o team Python? 👇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) Bienvenidos a Dev&Ops y la saturación tecnológica(03:45) Artículo 1: Usar Python en lugar de Bash Scripting(08:15) La portabilidad de scripts en diferentes sistemas operativos(16:30) Veredicto: Python para local, Bash para servidores(22:30) Artículo 2: La trampa de usar la herramienta "correcta"(28:20) ¿Reemplazar Redis, Mongo y Pinecone solo con PostgreSQL?(38:45) Complejidad vs Robustez en arquitecturas de bases de datos(44:00) Artículo 3: El misterio de las aplicaciones Local First(48:25) El verdadero reto: Sincronización, HLCs y conflictos CRDTs(54:45) ¿Hay mercado real para las aplicaciones Local First?(01:03:30) Conclusiones, comentarios y despedida#devops #programacion #python #bash #postgresql #basededatos #localfirst #softwarearchitecture #backend #podcasttecnologico #desarrollodesoftware

En este episodio de Dev&Ops analizamos un debate que ya no es debate: ¿por qué Linux terminó dominando los servidores web y de aplicaciones?Recorremos la historia desde los 90s: Perl, CGI, PHP, Java, ASP, ColdFusion, el nacimiento del stack LAMP, el auge de Apache y NGINX, y cómo la comunidad open source inclinó definitivamente la balanza.No es una conversación basada en fanatismo. Es un análisis histórico y técnico sobre costos, rendimiento, comunidad, estabilidad y cómo la nube terminó de consolidar el dominio de Linux en la web.🔍 En este episodio aprenderás:Cómo el stack LAMP revolucionó el desarrollo webPor qué el modelo open source aceleró la adopción de LinuxQué papel jugaron PHP, Java, Ruby y ASP en esta batallaCómo el rendimiento y la arquitectura multiusuario marcaron la diferenciaPor qué la nube terminó de consolidar el dominio de LinuxEn qué áreas Windows sigue siendo el rey (Exchange y Active Directory)📑 Capítulos recomendados (00:00) Introducción al EP50 (02:10) ¿Linux vs Windows en servidores? Una batalla ya ganada (05:46) ¿Qué pasaría si hoy te pidieran montar un servidor web en Windows? (09:11) Servidores Windows en los 2000: IIS, NT y Windows 2000 (12:00) El factor costo: licencias vs open source (16:01) Linux como puerta de entrada para desarrolladores (21:00) Los lenguajes que marcaron la historia web (Perl, CGI, C/C++) (29:40) El nacimiento de PHP y el auge del stack LAMP (31:44) Ruby on Rails y su impacto en la web (37:42) ColdFusion, enterprise y software propietario (43:38) ASP y el ecosistema cerrado de Windows (46:45) Java y la era de los Servlets (51:33) Open source vs propietario: quién inclinó la balanza (57:44) Comunidad, Apache y la consolidación de Linux (1:01:03) Automatización y facilidad de despliegue (1:03:21) Estabilidad, rendimiento y arquitectura multiusuario (1:13:21) Microsoft adopta Linux en la nube (1:16:00) La nube como golpe final a la batalla (1:18:00) Conclusiones: hechos históricos, no fanatismo

¿Tratas a tu base de datos como un simple cajón donde guardas cosas o como el motor principal de tu aplicación? En este episodio de Dev&Ops, Juan y Douglas se sumergen en el mundo de las bases de datos desde la perspectiva del desarrollador.Hablamos sobre por qué no todo es responsabilidad del DBA y cómo decisiones simples —como elegir el tipo de dato correcto o entender el orden de un índice compuesto— pueden salvar la billetera de tu empresa (y tu salud mental). Exploramos la normalización, el arte de saber cuándo romperla, el uso de transacciones atómicas para evitar desastres y el famoso "Soft Delete". Si quieres que tu aplicación escale sin necesidad de lanzarle más RAM al problema, este episodio es para ti. ¡Dale play y optimiza tu stack!Ú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) Intro y bienvenida al podcast(02:07) El rol del desarrollador frente a la base de datos(08:45) Normalización: 1ra, 2da y 3ra Forma Normal explicada(14:16) Por qué quien entiende la base de datos entiende la aplicación(19:20) Excepciones: ¿Cuándo es bueno duplicar datos?(22:30) Tipos de datos: El impacto de elegir bien el tamaño(27:44) Cómo se hace una auditoría de base de datos real(33:00) Constraints y reglas de negocio: El último bastión de seguridad(35:48) Transacciones atómicas a nivel de código vs DB(43:08) Columnas de auditoría y el secreto del Soft Delete(49:04) Índices compuestos: Por qué el orden de las columnas lo cambia todo(54:29) Optimizar código vs. escalar recursos: El golpe a la billetera#devops #basesdedatos #sql #programacion #backend #performance #systemdesign #desarrollodesoftware #tecnologia #dbmanagement

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 nubeCuándo necesitas runners privados, efímeros o con KubernetesCómo funciona el cache en CI/CD y por qué puede reducir builds de 40 a 6 minutosQué son los artifacts y por qué son clave para rollbacksCómo y por qué usar un container registry propioQué 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 pipelinesCómo usar curl para interactuar con APIs, webhooks y health checksPara qué sirve awk al procesar outputs y logs en pipelinesCómo jq y yq ayudan a trabajar con JSON y YAMLQué es envsubst y cómo usar templates con variables de entornoPor 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 2026Cómo interpretar años de experiencia y requisitos “inflados”Qué tecnologías siguen siendo clave en DevOps y desarrolloLa importancia del inglés, portfolios y experiencia demostrablePor qué no necesitas saber “todo” para aplicar a un buen puestoDiferencias entre puestos senior, mid y contractorQué 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

¡Bienvenidos a nuestro segundo episodio de 2026! Después de las fiestas y con la energía renovada (aunque todavía un poco "llenos" por la comida festiva), Juan y Douglas Barahona se sumergen en uno de los temas más recurrentes y peligrosos en el mundo de la tecnología: el Overengineering. En esta charla, exploramos por qué tenemos ese impulso casi natural de diseñar soluciones extremadamente complejas para problemas que aún no existen y que, probablemente, nunca tendremos. Compartimos anécdotas reales desde las trincheras —desde bases de datos legacy hasta automatizaciones innecesarias— y discutimos cómo la experiencia nos ha enseñado a valorar la simplicidad sobre el ego técnico. 🚀 Lo que aprenderás en este episodio:Definición clara: ¿Qué es realmente el overengineering y en qué se diferencia del future proofing? Banderas Rojas: Cómo identificar si estás pasando más tiempo en la arquitectura que en la lógica de negocio. Impacto en el equipo: Por qué la complejidad cognitiva dificulta el mantenimiento y la colaboración. Herramientas para combatir el exceso: Aplicando conceptos como YAGNI, KISS y el enfoque MVP. Casos reales: Douglas nos cuenta cuándo es mejor optar por un proceso manual que por una infraestructura como código (IaC) excesiva. No permitas que la "sobre-ingeniería" retrase tus despliegues ni agote tu presupuesto.¡Ú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 🎧📑 Chapters:(00:00) Introducción y regreso a la realidad en 2026 (03:40) Definiendo el Overengineering: ¿Estamos resolviendo problemas fantasma? (07:05) Experiencias de juventud: El error de las soluciones excesivas (11:00) Lecciones de una base de datos legacy: El caso del drop-down (14:30) Bandera Roja #1: Configuración vs. Lógica de negocio (21:05) Bandera Roja #2: Demasiados pasos para tareas sencillas (24:00) Caso de estudio: ¿Rundeck o un simple Pipeline de GitLab? (31:00) El factor humano: Escuchar al equipo y controlar el ego profesional (38:00) Desventajas críticas: Tiempo, dinero y mantenimiento costoso (45:00) Cuando la automatización es una herejía: El caso CloudFormation (52:30) Diferencias clave: Future Proofing vs. Overengineering (59:00) El escudo contra la complejidad: YAGNI, KISS y el poder del MVP (01:06:00) Conclusiones y cierre del episodio #devops #overengineering #futureproofing #arquitecturadesoftware #yagni #kiss #mvp #programacion #desarrollodesoftware #tecnologia #mantenimiento #escalabilidad #ingenieriadesoftware #podcast 

En este episodio hablamos abiertamente sobre las metas y la dirección de Dev&Ops para 2026. No se trata de promesas vacías, sino de objetivos concretos basados en lo que ya hemos construido y en lo que queremos mejorar como proyecto y como comunidad.Conversamos sobre la importancia de tener un plan, aunque no sea perfecto, y cómo esa claridad nos permite mantener consistencia, mejorar el contenido y entregar más valor a quienes nos escuchan y nos ven.Hablamos de mantener el episodio semanal, de hacer más directos (lives) con contenido práctico y participación de la audiencia, de traer invitados que sumen experiencia real, de crear contenido escrito como complemento al podcast y de hacer crecer las redes sociales para que el contenido llegue a más personas.Este episodio es una invitación a crecer juntos y a construir Dev&Ops de forma intencional.📑 Capítulos:(00:00) Intro y contexto del episodio(02:10) Por qué es importante definir metas como proyecto(04:25) Tener un plan, aunque no sea perfecto(06:15) Meta 1: mantener el episodio semanal(10:40) El esfuerzo real detrás de la constancia(13:50) Meta 2: más directos (lives) y contenido hands-on(19:20) Qué tipo de directos queremos hacer(24:30) Meta 3: traer invitados y colaboraciones(29:40) Meta 4: contenido escrito y por qué sigue siendo valioso(33:00) Meta 5: crecer en redes sociales con intención(38:45) Comunidad, feedback y cierre del episodio

¡Bienvenidos a un episodio muy especial y emotivo de Dev&Ops! 🎉Hoy colgamos un rato las teclas y los comandos de terminal para sentarnos a charlar "a calzón quitado" sobre lo que ha sido este increíble viaje de 2025. Juan y Douglas reflexionan sobre los primeros 9 meses oficiales del podcast (¡aunque la planeación tomó casi dos años!).En este especial no solo celebramos la constancia, sino que compartimos la realidad detrás del micrófono: los retos técnicos, la importancia de la iluminación sobre la cámara, y cómo organizarse para no morir en el intento.¿Qué vas a encontrar en este episodio?🎂 La historia de origen: Cómo pasamos de la idea a la acción en marzo de 2025.💡 Consejos para creadores: Lo que nos hubiera gustado saber antes de iniciar un podcast.👨‍💻 Debate de Títulos: ¿Middle-Tier Administrator, SRE o Cloud Engineer? Ponemos orden en los nombres de puestos TI.🏆 El Top 3: Revelamos nuestros episodios favoritos del año (desde WordPress hasta Soft Skills).🌱 Crecimiento Personal: Lecciones aprendidas fuera del código.Gracias infinitas a cada uno de ustedes por escucharnos, comentar y ser parte de esta comunidad. ¡Nos vemos en el 2026 con más tecnología, más DevOps y más código!¡Ú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 🎧📑 Chapters:(00:00) Inicio y agradecimientos: Un año de esfuerzo compartido(02:33) Recapitulando el 2025: Sentimientos encontrados y satisfacción(05:11) La Historia de Dev&Ops: De la planeación al lanzamiento(07:21) Consejos para iniciar un Podcast: Luces, audio y procesos(11:19) Repaso de temas técnicos: Rompiendo las reglas del libro(14:15) La realidad vs. Las "Best Practices" en la industria(19:09) SysAdmin, SRE y la evolución de los puestos de trabajo(22:18) ¿Cómo nombrar correctamente los cargos en Tecnología?(28:50) El Top 3 de Douglas: Soft Skills, Emprendimiento y Tips(35:45) El Top 3 de Juan: WordPress, Trabajo en USA y Rob Pike(39:32) Crecimiento Personal: Lo que nos dejó el podcasting este año(46:50) Mensaje final a la comunidad y cierre del 2025TakeawaysAgradecimiento a Dios por las oportunidades recibidas.La importancia de invertir recursos en proyectos.Las conexiones personales enriquecen las conversaciones.Las conversaciones pueden ser entretenidas y divertidas.La alineación de pensamientos facilita la comunicación.Reflexionar sobre el tiempo y los recursos disponibles.Las sinergias en las conversaciones son valiosas.El crecimiento personal requiere esfuerzo y dedicación.Las relaciones interpersonales son clave para el éxito.La diversión puede coexistir con el trabajo serio.#devandopspodcast #podcast #tecnología #aniversariopodcast #recap2025 #vidadeprogramador #sysadminvsdevops #sresitereliabilityengineering #consejosparapodcasters #crecimientoprofesionalit #emprendimientotech #wordpresshosting #dockervskubernetes #softskillsparaprogramadores #trabajoremoto #douglasyjuan #findeañotech

En este episodio de Dev&Ops, Douglas y Juan se meten en una de las preguntas más importantes para cualquier profesional en tecnología:👉 ¿Cuánto necesitamos entender realmente “lo que pasa por debajo”?Hoy usamos frameworks, cloud, IA, automatización y herramientas que nos abstraen cada vez más de los detalles técnicos. Pero:¿Eso nos hace mejores profesionales?¿O estamos perdiendo fundamentos importantes?¿Dónde está el equilibrio entre productividad y entendimiento real?Durante la conversación hablamos de:Qué son las capas de abstracción en tecnología.Por qué entender los fundamentos sí agrega valor, aunque no los uses todos los días.Casos reales donde el conocimiento low-level marca la diferencia.Por qué saber “cómo se hacía antes” no es nostalgia, sino contexto.El rol de la IA, Stack Overflow y el copy-paste en nuestra forma de aprender.Cómo encontrar un balance sano entre aprender lo nuevo y entender lo esencial.Cuándo no vale la pena profundizar… y cuándo sí.Un episodio ideal para:DevelopersDevOps / SRE / SysAdminsCloud EngineersPersonas que están creciendo en su carrera techCualquiera que se haya preguntado: “¿Realmente necesito saber esto… o solo que funcione?”📑 Capítulos:(00:00) Introducción(00:53) Bienvenida al episodio(01:47) Tecnología en series y ficción(03:21) Tema central: hasta dónde entender las capas de abajo(05:08) Capas de abstracción explicadas(07:27) Curiosidad técnica vs balance personal(10:33) Aclaración importante: no es hate generacional(12:58) Antes de la nube: compilar todo a mano(15:33) Cuando el conocimiento se vuelve abstracto(18:09) Troubleshooting sin herramientas modernas(21:01) “Nosotros éramos el Splunk”(23:22) Ventajas reales del conocimiento low-level(27:03) El conocimiento como memoria muscular(30:00) Lo nuevo vs lo viejo en programación(34:30) ¿Saber cómo se hacía antes da ventaja hoy?(36:42) El valor aparece cuando nadie más puede resolverlo(42:08) La IA no creó este problema(46:19) El riesgo de usar sin entender(48:04) Entender el porqué de las decisiones técnicas(54:12) Encontrar el equilibrio correcto(59:18) Leer documentación como regla mínima(1:03:07) El tiempo como factor clave para aprender(1:07:08) Regla de oro: no entregar lo que no entiendes(1:09:50) Reflexión final(1:11:11) Despedida

¿Es tu código realmente seguro? En este episodio de Dev&Ops, Juan y Douglas repasan las Buenas Prácticas de Seguridad esenciales que todo desarrollador debe aplicar antes de salir a producción.Cubrimos desde la validación básica de formularios hasta estrategias avanzadas de hashing y manejo de errores, incluyendo una anécdota real sobre por qué nunca debes dejar logs de debug activados. Si quieres blindar tu aplicación contra el 98% de los ataques automatizados, esta guía es para ti.En este episodio aprenderás: ✅ Cómo validar inputs y outputs para evitar inyecciones. ✅ La importancia de los permisos de archivos y directorios. ✅ Cifrado de contraseñas: Hashing y Salt explicados. ✅ Por qué y cómo implementar Cookies seguras (HttpOnly). ✅ Manejo correcto de errores para no exponer información sensible.¡Ú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 🎧📑 Chapters:(00:00) Intro: La amenaza de los Bots(00:58) Bienvenida y crecimiento profesional(02:07) Tip 1: Validación de Inputs y Outputs(06:45) Prevención de SQL Injection y subida de archivos(13:58) Tip 2: Gestión de Permisos (Cuidado con 777)(17:55) Tip 3: Cifrado, Hash y Salt (28:00) Tip 4: Autenticación Multi-Factor (MFA)(31:37) Tip 5: Cookies Seguras y HttpOnly(34:00) Tip 6: Manejo de Errores (Dev vs Prod)(40:07) Historia Real: El error de las Tarjetas de Crédito 💳(44:20) Tip 7: Actualización de Dependencias y NPM(52:30) Tip 8 y 9: Queries Parametrizados y Sanitización (XSS)(01:00:10) Conclusión: Asegura tu aplicación hoy

En este episodio profundizamos en cómo asegurar una aplicación o sitio web desde el lado de sistemas, con tips prácticos que cualquier SRE, SysAdmin o ingeniero de infraestructura debe implementar sí o sí.Douglas explica:🔐 Protección desde el Edge (WAF, DDoS, rate limits, challenge pages) – Por qué Cloudflare es hoy una de las mejores herramientas (incluso en su plan gratuito). – Cómo bloquear países, bots, endpoints críticos y ataques comunes como XSS, SQL injection o brute force.🌐 Encriptación y seguridad entre el proxy y el servidor – Cómo y por qué encriptar toda comunicación con Origin Certificates, TLS/SSL y buenas prácticas modernas. – Evitar el bypass directo al servidor bloqueando todo tráfico excepto el proveniente del CDN o WAF.🛡️ Uso correcto de NGINX / Traefik como reverse proxy – Por qué no deberías exponer directamente tu application server (Node, Go, Python, PHP). – Manejo de headers de seguridad, CORS, ocultamiento de información sensible y logging responsable.💾 Cifrado de datos en reposo y en tránsito (Encryption at Rest & Transit) – Cuándo aplicarlo, por qué algunos estándares lo exigen y qué impacto real tiene en rendimiento.Además, discutimos casos reales, errores comunes y cómo pensar como un atacante para reducir el riesgo.Un episodio sumamente útil para cualquier equipo que quiera mejorar su postura de seguridad sin gastar miles de dólares en infraestructura.📑 Capítulos:(00:00) Intro(01:26) Presentación del tema: Seguridad desde el lado SRE / SysAdmin(04:00) ¿Qué tan involucrado está un developer en la seguridad de una app?(09:57) La colaboración entre SRE, seguridad y desarrollo(11:33) El rol de infraestructura vs. el rol del equipo de seguridad(14:42) Experiencia real: Cumplimiento de PCI y estándares críticos(17:10) Cómo pensar el flujo de un request: de arriba hacia abajo(18:40) Tip #1: Protección desde el Edge (WAF, CDN, DDoS, Rate Limit) (22:30) Usando challenges, bloqueo por país y reglas anti-bots (24:17) Protección de páginas de login y paneles administrativos (27:30) Cloudflare Zero Trust y accesos controlados (29:39) ¿Por qué no aplicar rate limit en el código? (31:14) La realidad del tráfico malicioso en internet (34:22) Tip #2: Encriptar la conexión entre el proxy y tu servidor (36:39) Certificates, Origin Certs y buenas prácticas TLS (38:52) El gran error: permitir tráfico directo a tu servidor (41:49) Ejemplo real: El ataque constante a servidores expuestos (46:10) El impacto del SSL hoy en día y cómo ha cambiado la industria (47:15) Repaso: Edge + Origin Lockdown + Certificados (47:56) Tip #3: Usar NGINX o Traefik como reverse proxy obligatorio (50:43) Por qué no deberías exponer directamente tu application server (52:47) Reglas, CORS, headers, ocultamiento y logs (55:42) Qué no se debe loggear por seguridad y legalidad (56:25) Con estos primeros 3 tips bloqueás el 95% de ataques (58:29) Tip situacional: Encryption at Rest y seguridad interna (01:00:12) Cuándo encriptar discos, bases de datos y servicios internos (01:02:35) Impacto del cifrado en rendimiento: mito vs realidad (01:05:49) Resumen: El mínimo obligatorio para cualquier aplicación (01:06:10) Cierre del episodio + Reflexión final (01:08:40) Despedida

El diseño de un sistema define no solo cómo se escribe el código, sino cómo escala, cuánto cuesta y qué tan difícil será mantenerlo. En este episodio de Dev&Ops, realizamos un análisis técnico y operativo de los cuatro patrones de arquitectura de software más importantes en la industria actual.Juan (Backend) y Douglas (Infraestructura) desglosan cada arquitectura para entender sus casos de uso reales, más allá de las tendencias del momento. Profundizamos en:- Monolítica: Por qué sigue siendo el estándar para MVPs y la mayoría de aplicaciones, y sus ventajas en depuración (debugging).- Serverless: La realidad operativa detrás de las funciones "sin servidor", los Cold Starts y el Vendor Lock-in.- Microservicios: La complejidad de orquestar múltiples bases de datos y servicios, y por qué requiere una cultura DevOps madura.- Event-Driven (Basada en Eventos): Cómo desacoplar procesos usando Brokers (Kafka/RabbitMQ) para mejorar la resiliencia y la experiencia de usuario.Si estás tomando decisiones técnicas para un nuevo proyecto o planeando una migración, este análisis te dará el criterio necesario para elegir la mejor opció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 🎧📑 Chapters:(00:00) Introducción: La importancia de elegir la arquitectura correcta(04:03) Definición y objetivos: Escalabilidad y mantenibilidad(16:39) Análisis: Arquitectura Monolítica (Ventajas y Desventajas)(34:29) Análisis: Arquitectura Serverless y sus retos operativos(39:09) Análisis: Microservicios y la necesidad de madurez DevOps(56:00) Análisis: Arquitectura Basada en Eventos (Event-Driven)(1:07:16) Message Brokers: Diferencias entre RabbitMQ y Kafka(1:21:42) Conclusión y recomendaciones finales#arquitecturadesoftware #diseñodesoftware #serverlessarchitecture #microservicesarchitecture #eventdrivenarchitecture #rabbitmq #kafka #cqrs

En este episodio de Dev&Ops, Douglas y Juan ponen frente a frente dos tecnologías clave en la industria: Kubernetes y Docker Swarm.A primera vista, Kubernetes parece el ganador indiscutible —y técnicamente, lo es—, pero la conversación profundiza en lo verdaderamente importante:👉 ¿Cuál es la mejor opción para tu aplicación, tu equipo y tus necesidades reales? Porque la respuesta cambia completamente cuando tomamos en cuenta contexto, complejidad, tipos de servicios, frecuencia de despliegues y las capacidades del equipo técnico.Durante la discusión, exploran temas como:Funcionalidades avanzadas de Kubernetes (autoscaling, creación de recursos dentro y fuera del clúster, integración con proveedores externos, certificados, networking avanzado, etc.)Simplicidad y casos de uso ideales para Docker Swarm.Cómo saber si la complejidad de Kubernetes vale la pena o si Swarm es más que suficiente.Qué elementos del producto, arquitectura y ritmo de releases determinan cuál herramienta elegir.La importancia del contexto, más allá del hype tecnológico.Un episodio indispensable si trabajás con contenedores, infraestructura, DevOps o desarrollo backend, o si estás evaluando qué tecnología adoptar para tu equipo.📑 Capítulos(00:00) Introducción y presentación del episodio(01:56) Por qué hacemos episodios “Versus” (objetividad y experiencia real)(03:07) Cómo evaluar tecnologías desde la realidad de cada equipo(04:00) Inicio del Versus: Kubernetes vs Docker Swarm(04:52) “Objetivamente Kubernetes es mejor”… y el verdadero enfoque del episodio(06:10) El error de preguntar “¿Cuál es mejor?” sin contexto(08:45) Contexto real: cómo interactúan devs, ops y equipos completos con un orquestador(12:30) Experiencia de Juan usando Swarm y Kubernetes en entornos reales(14:00) Complejidad vs simplicidad: analogía del reloj suizo(16:40) Flexibilidad y modularidad en Kubernetes (microservicios, múltiples versiones, gRPC, eventos)(20:00) ¿Cuándo Kubernetes es necesario y cuándo no?(22:45) Qué tanto influye el stack, el tamaño y la madurez del equipo(26:10) “Kubernetes no es gratis”: costos, esfuerzo y curva de aprendizaje(30:20) Casos donde Docker Swarm encaja perfectamente(33:10) El rol del equipo: capacidades, skills y mantenimiento(36:00) Crear recursos dentro y fuera de Kubernetes (DNS, storage, networking, load balancers)(40:00) Crossplane, infraestructura externa y funcionalidades avanzadas de Kubernetes(42:30) Limitaciones de Swarm en comparación(45:40) Cuándo Swarm gana por simplicidad y estabilidad(48:00) Autoescalado: nodos, pods, spot instances y gestión dinámica en Kubernetes(53:25) Diferencias reales entre autoscaling en Kubernetes y Swarm(56:00) ¿Tu app lanza nuevas apps/servicios con frecuencia? Entonces Kubernetes(59:30) Node pools avanzados y scheduling inteligente en Kubernetes(1:02:00) Cuando no necesitas esa complejidad y Swarm es suficiente (1:05:45) Tráfico predecible, servicios estáticos y Swarm como mejor elección (1:10:39) La magnitud de lo que ofrece Kubernetes (listado de capacidades) (1:14:40) Reflexión sobre especializarse en Kubernetes y tecnologías cloud (1:17:00) Recomendaciones finales según tipo de equipo y tipo de aplicación (1:20:00) Conclusiones generales del Versus (1:22:30) Cierre y agradecimiento a la audiencia

¿Sigues subiendo archivos por FTP o haciendo builds manuales en tu PC? 😅 ¡Es hora de modernizar tu flujo de trabajo!En el episodio 35 de Dev&Ops, Juan y Douglas desglosan todo lo que necesitas saber sobre CI/CD (Continuous Integration / Continuous Delivery). Descubre por qué el primer paso NO es el código ni la infraestructura, sino cambiar la mentalidad de tu equipo.Aprende cómo puedes empezar hoy mismo, incluso si tu proyecto es pequeño. Te mostraremos cómo construir tu primer pipeline automatizando solo dos pasos: el Build y el Deploy. ¡Este es el verdadero punto de partida para eliminar el error humano y ganar confianza en tus despliegues!En este episodio cubrimos:- ¿Qué es realmente CI/CD? (La analogía de la fábrica 🤖).- El error más común al empezar y por qué la mentalidad es lo primero.- El pipeline "mínimo viable" que puedes implementar ¡hoy mismo!- Por qué hasta un sitio simple en HTML y CSS se beneficia de CI/CD.- Cómo y cuándo empezar a agregar Pruebas Unitarias (sin buscar el 100% de coverage).- Pasos avanzados: Escaneo de vulnerabilidades y post-deployment jobs (como limpiar la caché).Si tu equipo aún no tiene un pipeline, ¡este episodio es el empujón que necesitas! Dale play y cuéntanos en los comentarios: ¿Cuál es el mayor reto que enfrentas al intentar automatizar?Para Pensar:- Por pequeño que parezca tu sitio, se beneficia de CI/CD.- Implementar CI/CD en proyectos universitarios es valioso.- CI/CD en demos de presentación mejora el portafolio.- La experiencia no es necesaria para implementar CI/CD.- CI/CD puede ser un diferenciador en el currículum.- Los proyectos pequeños también pueden utilizar CI/CD.- La implementación de CI/CD es una buena práctica.- CI/CD ayuda a mantener la calidad del código.- Agregar CI/CD a tu portafolio es una ventaja.- La práctica de CI/CD es relevante en cualquier etapa del desarrollo.¡Ú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) ¿Por qué hasta un sitio HTML necesita CI/CD?(04:34) ¿Qué es CI/CD? La analogía de la fábrica.(07:00) El objetivo: Eliminar el error humano.(10:40) El VERDADERO primer paso: Cambiar la mentalidad.(27:02) El pipeline MÍNIMO para empezar (Build + Deploy).(32:27) Agregando Pruebas (Unit Tests) sin volverse loco.(47:11) Pasos avanzados: Pruebas de vulnerabilidades y sintaxis.(54:00) Jobs Post-Deployment (Limpiar caché y notificaciones).#cicd #cicdpipeline #desarrollodesoftware #pipeline #experiencia #devops #developers #devandopspodcast

Negociar un aumento salarial sigue siendo uno de los temas más incómodos y menos enseñados en nuestra carrera profesional —especialmente en IT—, pero también uno de los más importantes para nuestro crecimiento.En este episodio de Dev&Ops, Douglas y Juan comparten sus experiencias personales y profesionales sobre cuándo y cómo pedir un aumento, cómo prepararte con métricas reales, cómo medir tu propio impacto y cómo comunicar tu valor a la empresa.Conversamos sobre:Cómo prepararte para pedir un aumento como si fuera un proyecto técnico 🧠Qué hacer si tu empresa no tiene procesos formales de evaluaciónQué errores evitar al justificar tu solicitudCómo elegir el momento ideal (evaluaciones, aniversarios laborales, logros clave)Por qué demostrar tu valor con datos y resultados es la mejor estrategiaYa sea que trabajes como developer, sysadmin, DevOps o project manager, este episodio te ayudará a construir una estrategia sólida para negociar mejor tu salario sin poner en riesgo tu relación laboral.📑 Chapters:(00:00) Introducción y Bienvenida(02:04) Negociación de Salarios: Un Tema Tabú(14:23) Estrategias para Solicitar Aumentos(20:41) Preparación para la Solicitud de Aumento(27:28) Mentalidad Proactiva en el Trabajo(30:13) Negociación de Aumentos Salariales(32:01) Demostrando Valor en la Empresa(40:46) La Importancia del Ownership(46:59) Conociendo el Mercado Laboral(54:27) Salarios en Latinoamérica vs Estados Unidos(01:02:42) Estrategias para Negociar Aumentos Salariales(01:12:21) La Importancia de Justificar un Aumento(01:19:37) Cierre y Reflexiones Finales

Como desarrolladores, a menudo trazamos una línea y pensamos que la infraestructura "es cosa de DevOps". En este episodio especial, Juan comparte su experiencia personal construyendo un HomeLab desde cero y cómo este proyecto ha impactado su perspectiva profesional.Hablamos sobre el valor de ir más allá del editor de código. El viaje cubre desde la elección del hardware (Orange Pi vs. Raspberry Pi) y la configuración de redes (TP-Link OMADA, VLANs), hasta la selección de un Sistema Operativo (Armbian) y la orquestación de contenedores (Docker Swarm).Juan detalla su setup usando herramientas modernas como DokPloy para la gestión de despliegues y Traefik como reverse proxy. Explica los desafíos y aprendizajes prácticos (backups, seguridad, gestión de recursos) que no siempre se obtienen al usar plataformas "listas para usar" como Vercel o AWS. El Resultado: Cómo esta experiencia práctica cambia tu mentalidad y te ayuda a tomar mejores decisiones en tu trabajo diario como developer.Un episodio fundamental para cualquier profesional que busque entender el "Ops" de Dev&Ops y ampliar su visión del ecosistema tecnológico.Para Pensar💡- El HomeLab es un proyecto personal que puede ser realizado en casa.- La parte física del hardware puede ser intimidante al principio.- La experiencia personal puede cambiar la percepción de tareas técnicas.- La práctica es clave para aprender a configurar redes.- Los errores en la configuración son parte del proceso de aprendizaje.- El interés personal puede motivar a superar desafíos técnicos.- Crear un HomeLab puede ser una forma de aprender sobre servidores.- La conexión entre dispositivos es fundamental en un HomeLab.- La experiencia previa puede influir en la confianza al trabajar con hardware.- Transformar tareas tediosas en proyectos puede hacerlas más atractivas.📑 Chapters:(00:00) Introducción: ¿Por qué un HomeLab? (01:21) El Miedo al "Metal": Perder el pánico al hardware (01:34) La Pesadilla del RJ45 (03:00) Hardware: Orange Pi vs. Raspberry Pi (04:15) Lección Clave: Gestionar Recursos Reales (16GB vs 2GB RAM) (05:44) El Reto de Montar Discos Duros (06:54) Configurando la Red: Routers, Switch y VLANs (07:33) El Poder de un Controlador de Red (TP-Link OMADA) (08:44) El truco: Una sola Red WiFi para Múltiples VLANs (09:23) OMADA vs. Ubiquiti UniFi (10:51) ¿Quieres ser DevOps/SRE? ¡Empieza aquí! (11:51) Sistemas Operativos: Más allá de Ubuntu (Armbian, Fedora) (14:14) Orquestación: Usando Docker Swarm (15:23) La "Nube Casera": Coolify vs. DokPloy (16:35) ¿Por qué DokPloy? (Staging, Deploys, Monitoreo) (18:15) El Desafío de los Backups (19:41) Reverse Proxy: Nginx vs. Traefik (21:03) ¿Qué corro en mi HomeLab? (Jellyfin y Pi-hole) (22:25) El Riesgo: ¿Exponer tu HomeLab a Internet? (24:19) "Pero... yo solo soy Developer" (24:51) Recordando la era "Full Stack" (PHP, JS, Servidor) (26:38) Especialización vs. Visión Completa del Sistema(27:32) El "Clic" Mental: Cómo el HomeLab te hace mejor Dev (28:16) Beneficio Extra: Independencia de la Nube (28:55) Conclusión: No necesitas lo más caro para empezar (29:43) Despedida

En este episodio de Dev&Ops, Douglas y Juan exploran los indicadores más importantes que todo profesional de tecnología debería reconocer antes de tomar decisiones clave en su emprendimiento.💡 ¿Cómo saber cuándo pasar de un proyecto paralelo a un negocio real? 🚀 ¿Cuándo dejar el trabajo para dedicarte 100% a tu idea? 📊 ¿Qué métricas o señales te pueden ayudar a decidir con claridad?A través de su experiencia personal y casos reales, analizan señales como:Tener tu primer cliente o validación de mercado.Identificar cuándo tu trabajo actual ya no te deja crecer.Medir riesgos financieros sin paralizarte.Entender que igualar tu salario no es el único indicador.Un episodio práctico, honesto y lleno de reflexiones reales para quienes están construyendo su propio camino en el mundo del emprendimiento tech.📺 YouTube: https://www.youtube.com/@DevAndOpsPodcast 🎧 Spotify: https://open.spotify.com/show/1MuMODYsE4xN6RhOcd8EaG 📱 TikTok: https://www.tiktok.com/@devandops 📸 Instagram: https://www.instagram.com/devandopspodcast/ 📘 Facebook: https://www.facebook.com/devandopsChapters(00:00) Introducción: de empleado a emprendedor (03:15) El valor de aprovechar la experiencia corporativa (07:40) Primer indicador: tu primer cliente o validación (15:20) Segundo indicador: ¿cuándo dejar tu trabajo actual? (24:10) Cómo evaluar riesgos y medir preparación financiera (33:45) El error de esperar “igualar el salario” (42:55) Casos reales y señales personales de madurez emprendedora (55:00) Consejos finales para dar el salto con intención (01:03:00) Cierre y aprendizajes clave

Muchos emprendedores tech fallan antes de empezar por ignorar estos pasos. En la Parte 2 de 'Cómo Emprender', te damos el mapa completo para poner tu idea en marcha DE VERDAD.Juan y Douglas van más allá de la idea y se meten en la ejecución: ¿Cómo elegir a tus socios? ¿Es justo el 50/50? ¿Cuándo debes constituirte legalmente? ¿Remoto u oficina?Hablamos de las conversaciones difíciles que definen el éxito o fracaso, y por qué tu "perfeccionismo" de ingeniero puede matar tu proyecto antes de que vea la luz (¡y por qué necesitas un MVP!).¡Ú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 🎧Takeaways:No importa el tipo de negocio, sin venta no existe ganancia.La finalidad de la publicidad es la venta.Es necesario crear publicidad que sea llamativa.Transmitir el diferenciador del producto es clave.Es fundamental dar seguimiento a las preguntas en redes sociales.La única forma de que entre dinero a un negocio es que alguien consuma.Buscar a los posibles compradores es esencial.La venta es un proceso activo que requiere estrategia.La publicidad debe ser estratégica y enfocada en resultados.La atención al cliente es clave para cerrar ventas.📑 Chapters:(00:00) Introducción al Emprendimiento en Tecnología(07:34) Modelo de Negocio: La Base del Emprendimiento(21:26) La Importancia de los Socios en el Emprendimiento(29:46) La Importancia de la Alineación en Socios(31:43) Desafíos de la Colaboración y la Visión Compartida(34:08) Valores y Ética en la Asociación(37:58) Subcontratación: Elegir a las Personas Correctas(42:36) Definiendo el Espacio y la Forma de Trabajo(47:14) La Relevancia de los Roles y Horarios(56:37) Constitución Legal del Negocio(01:06:14) División de Porcentajes entre Socios(01:15:38) Apertura de Cuentas Bancarias y Créditos(01:27:57) La Importancia de las Ventas(01:33:17) Estrategias de Ventas Efectivas(01:39:51) Desarrollando un Catálogo de Productos(01:47:38) Definiendo un MVP para el Éxito#empreendedorismo #tech #softwareengineer 

En este nuevo episodio de Dev&Ops, Douglas y Juan arrancan una nueva serie dedicada al emprendimiento en tecnología. 🚀Comienzan hablando de cómo aprovechar al máximo la experiencia corporativa para prepararse estratégicamente antes de dar el salto a tu propio negocio. Desde el punto de vista técnico, administrativo y de negocio, comparten aprendizajes reales, errores y consejos prácticos para quienes sueñan con emprender —ya sea creando un producto, una agencia digital o un servicio tecnológico.💡 En este episodio aprenderás:Cómo sacar el máximo provecho del trabajo corporativo antes de emprender.Por qué entender todas las capas técnicas te prepara mejor como fundador.Qué habilidades administrativas debes desarrollar mientras eres empleado.La importancia de comprender el negocio detrás de cada aplicación o servicio.Cómo aplicar todo esto para construir una base sólida para tu emprendimiento.Este es el inicio de una nueva serie sobre cómo emprender en tecnología —con experiencias reales y lecciones que no encontrarás en los libros. 📘📑 Chapters:(00:00) Introducción al Podcast y Temas Generales(02:41) Emprendimiento en Tecnología: Una Nueva Serie(07:06) Aprovechando la Experiencia Corporativa(12:41) Aclaraciones sobre el Emprendimiento(17:44) Valorar la Opinión de los Expertos(20:41) Experiencias Personales en Emprendimiento(28:47) Introducción a la Experiencia Emprendedora(36:35) Aprovechando el Trabajo Corporativo para el Emprendimiento(54:17) Aprendiendo Procesos Administrativos en el Trabajo(01:05:58) La Importancia del Manejo Administrativo(01:13:21) Aprendiendo de la Experiencia Laboral(01:16:43) Conocimientos de Negocio para el Emprendimiento(01:37:17) La importancia de la experiencia en ventas(01:40:36) Adaptación y aprendizaje en el emprendimiento(01:42:04) Networking: Creando conexiones valiosas(01:45:56) Preparación y mentalidad para emprender(01:57:01) Identificando socios y colaboradores(02:02:02) Resumen y cierre del episodio

¿Sientes que estás siempre ocupado pero avanzas poco?  En este episodio de Dev&Ops, Juan y Douglas comparten sus trucos y estrategias personales para construir un flujo de trabajo que realmente funcione.Desde cómo manejar las interrupciones constantes hasta configurar tu entorno local para máxima eficiencia, te damos consejos prácticos que puedes empezar a usar hoy mismo. Descubre por qué los métodos de productividad tradicionales a veces no encajan en el mundo de la tecnología  y cómo crear un sistema personalizado que te permita recuperar el control de tu tiempo.📑 Chapters:(00:00) Adelanto(00:59) Introducción(06:12) Desafíos de la Distracción en Tecnología(10:51) Autocontrol y Organización Personal(15:59) Métodos de Productividad y Flexibilidad(21:13) Consejos Prácticos para Mejorar la Productividad(28:54) Estructura y Flexibilidad en el Trabajo(31:55) Planificación y Organización del Tiempo(36:46) Revisión y Ajuste de Tareas(39:54) Framework Personal para la Productividad(43:51) Herramientas y Métodos para la Eficiencia(46:09) Notas y Seguimiento de Tareas(52:34) Organización y Productividad Personal(01:00:13) Métodos de Toma de Notas(01:00:43) Herramientas y Entornos de Trabajo(01:14:26) Configuración de SSH y Seguridad(01:20:19) Configuración Eficiente de Herramientas(01:26:06) Consejos para Mejorar la Productividad(01:33:16) Ambiente de Trabajo y Comodidad(01:47:28) Cierre y Reflexiones Finales💡 Takeaways- La estructura es clave para un flujo de trabajo eficiente.- Las distracciones son comunes en el trabajo tecnológico.- El autocontrol es esencial para mantener la productividad.- Definir tiempos de enfoque ayuda a evitar distracciones.- La planificación diaria mejora la organización del trabajo.- Las notas son herramientas útiles para recordar tareas.- La flexibilidad en los métodos de trabajo es importante.- Implementar hábitos productivos requiere esfuerzo y constancia.- La comunicación clara sobre las expectativas es crucial.- Cada persona debe encontrar su propio método de organización. La cultura y la tecnología en DevOps son fundamentales para el éxito.- Cada persona tiene su propio método de organización y toma de notas.- El minimalismo en herramientas puede aumentar la concentración y la productividad.- Configurar adecuadamente el entorno de trabajo es clave para la eficiencia.- Las herramientas como snippets y configuraciones personalizadas pueden ahorrar tiempo.- Es importante encontrar un equilibrio entre comodidad y funcionalidad en el espacio de trabajo.- Las notificaciones personalizadas pueden ayudar a priorizar tareas importantes.- Invertir en un ambiente de trabajo cómodo puede mejorar la productividad.- La música puede ser una distracción o una ayuda, dependiendo de la persona.- La personalización del entorno de trabajo debe adaptarse a las necesidades individuales.#productividad #devops #eficiencia #desarrollodesoftware #automatización #devandopspodcast 

En este episodio de Dev&Ops, Douglas y Juan comparan archivos de configuración (YAML/JSON/INI/TOML) y variables de entorno: cuándo usar cada uno, cómo combinarlos sin dolor y qué buenas prácticas aplicar para evitar deuda técnica y riesgos de seguridad. Además, cubrimos automatización (CI/CD, Configuration Management) y manejo de secretos con herramientas como HashiCorp Vault y Secret Manager.🔍 En este episodio aprenderás:Diferencias reales entre config files y env vars y cómo convivir con ambos.Ventajas de legibilidad/estructura (archivos) vs. simplicidad/dinamismo (env vars). Buenas prácticas: versionado, separación del código, no hardcodear, y documentación. Dónde entra Configuration Management (p.ej., Ansible) para distribuir config de forma segura. Manejo de secretos (Vault, AWS/GCP Secret Manager, K8s Secrets) y qué no hacer.📑 Chapters(00:00) Introducción y Bienvenida(03:13) Configuraciones en Desarrollo y Operaciones(05:32) La Importancia de la Configuración(13:21) Archivos de Configuración vs Variables de Entorno(22:11) Ventajas y Desventajas de Archivos de Configuración(31:21) Conclusiones sobre Configuración y Buenas Prácticas(32:28) Ventajas y Desventajas de Archivos de Configuración(35:01) Variables de Entorno: Definición y Uso(38:09) Simplicidad y Dinamismo de las Variables de Entorno(41:52) Comparativa: Variables de Entorno vs Archivos de Configuración(49:55) Seguridad en el Manejo de Configuraciones(56:59) Preferencias en el Uso de Configuraciones(01:04:52) Preferencias en Configuración de Aplicaciones(01:11:03) Manejo de Variables de Entorno y Archivos de Configuración(01:16:48) Despliegue en Contenedores y su Configuración(01:25:54) Manejo Seguro de Secretos y Credenciales👇 ¡Ú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 🎧

¿Alguna vez te has preguntado qué harías diferente si pudieras reiniciar tu carrera en tecnología con la experiencia que tienes ahora? En este episodio, Juan y Douglas se sumergen en un fascinante ejercicio mental.Desde elegir un camino diferente como el desarrollo móvil hasta optimizar la ruta de aprendizaje en infraestructura, exploramos las decisiones clave que tomaríamos hoy. Hablamos sobre la importancia CRÍTICA de aprender inglés desde el día uno , cómo crear un roadmap de aprendizaje efectivo y por qué dominar los conceptos fundamentales (como algoritmos y redes) es más importante que nunca.Además, revelamos cómo usaríamos las herramientas modernas como la Inteligencia Artificial para acelerar el aprendizaje y compartimos una lección vital que ambos aprendimos por las malas: la importancia de las habilidades blandas y el trabajo en equipo.Si estás empezando en IT o buscas reorientar tu carrera, los consejos y reflexiones de este episodio te darán una ventaja invaluable.Déjanos en los comentarios, ¿qué harías diferente tú?¡Ú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 🎧📑 Chapters:(00:00) Introducción al Tema de la Conversación(03:09) Reflexiones sobre el Aprendizaje de Inglés(06:02) Acceso a la Información y su Impacto(08:57) Iniciando en Tecnología: Enfoques y Estrategias(11:55) Elección de Especialización en Tecnología(21:04) Explorando Nuevas Oportunidades en Desarrollo Móvil(27:58) Reflexiones Finales y Perspectivas de Futuro(29:28) Iniciando el Camino: Inglés y Roadmap(32:30) Perspectivas Generacionales en el Aprendizaje(35:54) Optimización del Tiempo y Proyectos Prácticos(39:21) Fundamentos de Programación y Aprendizaje Efectivo(43:13) Conceptos Fundamentales: Algoritmos y Estructuras de Datos(46:48) La Importancia de los Fundamentos en Tecnología(50:10) Linux y Redes: Aprendizaje Práctico(54:38) Estrategias de Aprendizaje en 2025(01:00:16) Documentación y Aprendizaje Eficiente(01:03:10) El Valor de los Tutoriales y Libros(01:06:05) Inteligencia Artificial en el Aprendizaje(01:10:23) La Evolución de la Programación con IA(01:14:24) Integrando IA en el Proceso de Aprendizaje(01:18:37) Entendiendo la Inteligencia Artificial(01:22:29) La Importancia del Trabajo en Equipo(01:27:11) Crecimiento Personal y Profesional(01:33:48) Reflexiones Finales y Consejos#tecnología, #aprendizaje, #programación, #infraestructura, #roadmap, #algoritmos, #desarrollo móvil, #inglés, #educación, #oportunidades, #tecnología, #aprendizaje, #Linux, #inteligenciaartificial, #trabajoenequipo, #programación, #redes, #desarrolloprofesional, #educación, #habilidadesblandas

En este episodio de Dev&Ops, Douglas y Juan analizan cómo la Infraestructura como Código (IaC) y el Configuration Management no son rivales, sino aliados que se complementan en entornos modernos de DevOps.Explicamos sus diferencias, cuándo aplicar cada uno y cómo integrarlos en un flujo de trabajo que mejore la confiabilidad, escalabilidad y mantenibilidad de tus sistemas. Además, compartimos buenas prácticas y experiencias reales usando herramientas como Terraform, Ansible, Puppet y Chef.🔍 En este episodio aprenderás:Diferencias clave entre IaC y Configuration Management.Por qué no se trata de elegir uno, sino de combinarlos.Ejemplos de flujos prácticos donde se complementan.Herramientas más usadas (Terraform, Ansible, Puppet, Chef).Buenas prácticas para mantener orden, consistencia y escalabilidad.Errores comunes a evitar al implementar ambos enfoques.📑 Chapters:(00:00) Introducción y Bienvenida(03:51) La Importancia de la Comunidad(06:43) Definición de Infrastructure as Code(13:00) Gestión de Configuración y Herramientas(15:52) Estado Deseado en Infraestructura(20:49) Historia de la Infraestructura y Configuración(31:54) El Futuro de la Infraestructura como Código(33:17) La Mentalidad del Estado Deseado(35:55) Facilitando el Disaster Recovery(37:15) Cocinar con Receta vs. Cocinar al Tanteo(39:03) La Evolución de la Infraestructura como Código(44:41) La Importancia de la Lógica en Infraestructura(49:48) Pros y Contras de las Herramientas de Infraestructura(54:01) Complementando Infraestructura como Código y Gestión de Configuración(01:03:47) Uso de Herramientas y Configuración(01:08:21) Errores Comunes en Infraestructura como Código(01:16:23) Documentación y Control de Versiones(01:20:27) Modularidad en Infraestructura como Código(01:27:00) Errores Comunes en Configuration Management(01:30:14) La Importancia del Code Review(01:36:03) Consejos para Desarrolladores Junior(01:42:49) Estandarización y Modularización en Proyectos(01:48:35) Explorando Infrastructure as Code en Proyectos Personales

¿Sientes que estás estancado haciendo tareas repetitivas? ¿Crees que para ser "Senior" solo necesitas aprender más frameworks y lenguajes de programación? En este episodio de Dev&Ops, rompemos los mitos más comunes sobre el crecimiento profesional en el mundo de la tecnología.Juan y Douglas profundizan en el debate: ¿qué diferencia realmente a un desarrollador Junior de un Senior? Descubre por qué la clave no está solo en tus habilidades técnicas, sino en un cambio fundamental de mentalidad. Si quieres dejar de ser un ejecutor de tareas y convertirte en un ingeniero que aporta valor estratégico, ¡este episodio es para ti! Dale play y acelera tu carrera.¡Ú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 🎧📑 Chapters:(00:00) Introducción(03:42) Transición de Junior a Senior: Mitos y Realidades(07:25) Diferencias entre Junior y Senior: Mentalidad y Responsabilidad(16:21) El Rol de la Inteligencia Artificial en el Desarrollo(18:40) Ownership: La Clave para el Crecimiento Profesional(24:39) Desafíos de los Juniors en un Mundo de IA(29:47) Evolución de la Inteligencia Artificial y Adaptación Profesional(36:52) Mentalidad Senior: Más Allá de las Habilidades Técnicas(43:51) La Importancia de la Comunicación y Mentoría(46:06) Pragmatismo en el Desarrollo: El Código como Medio(56:11) Ver Más Allá: Impacto de las Decisiones Técnicas(59:35) Confianza y Soluciones Innovadoras(01:02:59) Mentalidad de Ingeniero: De Junior a Senior(01:06:04) La Importancia de Preguntar y Entender el Porqué(01:11:15) Code Reviews: Aprendiendo y Contribuyendo(01:15:22) Adueñarse de Proyectos: Un Paso Hacia el Seniority(01:18:28) Consejos y Conclusiones finales💡 Para pensar:- La transición de junior a senior no es solo técnica.- La mentalidad y la responsabilidad son clave para ser senior.- El ownership implica conocer a fondo un feature o sistema.- La inteligencia artificial puede cambiar la naturaleza de las tareas repetitivas.- La comunicación efectiva es esencial en un equipo de desarrollo.- Los juniors deben aprender de las tareas repetitivas para crecer.- El mentoreo es una parte importante del rol senior.- No se trata solo de habilidades técnicas, sino de actitud.- La experiencia adquirida en tareas repetitivas es invaluable.- Los juniors deben sentirse cómodos pidiendo ayuda a los seniors. La mentoría es clave para el crecimiento profesional.- Tener una mentalidad senior implica ayudar a otros a crecer.- El pragmatismo es esencial en la toma de decisiones.- Las habilidades blandas son tan importantes como las técnicas.- Documentar y automatizar procesos mejora la eficiencia.- Es fundamental entender el impacto de nuestras decisiones en el equipo.- La colaboración y la comunicación son esenciales en el trabajo.- No hay que menospreciar las tareas repetitivas, son oportunidades de aprendizaje.- Es importante preguntar el porqué de las tareas asignadas.- El crecimiento profesional es un proceso que lleva tiempo.

En este episodio de Dev&Ops, Douglas y Juan ponen el foco en un tema crítico para cualquier ingeniero de sistemas, SRE o DevOps: cómo configurar alertas de manera eficiente.Hablamos de las mejores prácticas para evitar el famoso alert fatigue, cómo diferenciar entre alertas críticas, warning e informativas, y la importancia de diseñar alertas que realmente aporten valor.Si alguna vez has sufrido una lluvia interminable de notificaciones que no sirven para nada, este episodio es para ti. 🚨 Te compartimos consejos prácticos, ejemplos reales y herramientas que usamos en nuestro día a día para que configures alertas que te ayuden a dormir tranquilo.🔍 En este episodio aprenderás:Cómo diseñar alertas que realmente importan.Cuándo una alerta debe ser crítica y cuándo no.Estrategias para evitar el alert fatigue.Qué métricas y logs vale la pena convertir en alertas.Casos reales de buenas y malas configuraciones de alertas en producción.

En este episodio de Dev&Ops, Juan y Douglas se sumergen en el mundo de Serverless. ¿Es realmente la panacea que nos ahorra la gestión de servidores o una trampa de costos y dependencia tecnológica? Analizamos sus ventajas para desarrolladores, los peligros del "vendor locking" y cuándo podría ser el momento de migrar a otra arquitectura. Si estás pensando en usar Serverless para tu próximo proyecto o simplemente quieres entender por qué gigantes como Amazon Prime Video han dado un paso atrás, ¡este episodio es para ti! Temas clave:¿Qué es y qué no es Serverless? Ventajas: agilidad y enfoque en el código. Desventajas: costos ocultos, "cold starts" y seguridad. Alternativas que deberías considerar. ¡Ú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 🎧Chapters:(00:00) Introducción al Tema Serverless(04:32) Definición y Tipos de Soluciones Serverless(10:04) Beneficios y Atractivos de Serverless(16:12) Consideraciones y Desafíos de Serverless(22:48) Casos de Uso y Audiencia de Serverless(29:02) La Evolución de Serverless en Empresas(30:41) Mentalidad del Developer en Arquitectura Serverless(36:20) Serverless como Solución Temporal(41:14) Desafíos y Puntos Negativos de Serverless(45:40) Costos y Facturación en Serverless(53:00) Optimización y Recomendaciones en Serverless(56:02) Desafíos del Vendor Locking(01:00:24) Seguridad en Aplicaciones Serverless(01:06:05) Limitaciones de Serverless(01:09:41) Alternativas y Recomendaciones para Serverless(01:13:08) Kubernetes y Soluciones Avanzadas(01:19:18) Reflexiones Finales sobre Serverless

¿Quieres dar el salto de desarrollador a Ingeniero de Fiabilidad de Sitios (SRE) pero no sabes por dónde empezar? En este episodio, te damos la hoja de ruta completa.Hablamos de las competencias técnicas cruciales que todo SRE necesita: desde los fundamentos de Linux y redes , hasta el dominio de contenedores como Docker y Kubernetes. Descubre con nosotros cómo construir una base sólida para una transición de carrera exitosa en el mundo de DevOps.En este episodio cubrimos:- Mentalidad de Ingeniero: ¿Por qué no basta con solo saber codificar? - Sistemas Operativos: La importancia de entender Linux a fondo.- Contenedores y Virtualización: Docker, Kubernetes y los conceptos que los sustentan.- Networking: El pilar fundamental que no puedes ignorar.- Proveedores de Nube: AWS, Azure y Google Cloud como herramientas de trabajo.- Habilidades Blandas: Por qué la colaboración y la calma son vitales para un SRE.¡Ú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 🎧📑 Chapters:(00:00) Introducción y Propósito del Podcast(02:49) Transición de Desarrollador a SRE(06:33) Responsabilidades de un SRE(10:53) Atractivos de la Carrera SRE(14:52) Interacción con Clientes y Equipos(21:35) Habilidades Necesarias para SRE(31:07) Mentalidad y Enfoque en el Desarrollo(33:08) Habilidades Necesarias para la Transición(35:18) Profundizando en Sistemas Operativos37:59 La Importancia de la Virtualización y Networking42:28 Contenedores: Docker y Kubernetes44:12 Proveedores de Nube y su Relevancia50:08 Ciclo de Vida de la Aplicación y Mentalidad DevOps56:13 Aprendizaje Práctico y Curiosidad en el Trabajo01:01:59 Analogías de Aprendizaje y Curiosidad01:05:32 Colaboración y Mejora Continua01:11:54 Mentalidad y Colaboración en SRE01:17:10 Preparación para la Culpa y Resiliencia01:25:56 Recomendaciones y Herramientas para el Futuro

En este episodio, Douglas y Juan se adentran en un debate clásico en el mundo de la tecnología: CLI (Command Line Interface) vs GUI (Graphical User Interface), pero desde la perspectiva de la cultura DevOps. Analizamos ventajas, desventajas, casos de uso, ejemplos reales y cómo estas herramientas impactan en la productividad de desarrolladores, sysadmins e "ingenieros DevOps".Además, compartimos experiencias personales, trucos para optimizar tu flujo de trabajo y un divertido ejercicio práctico para descubrir qué prefieres tú: ¿la terminal o la interfaz gráfica?🔍 En este episodio aprenderás:Diferencias clave entre CLI y GUI en entornos DevOps.Ventajas y desventajas reales de cada enfoque.Cuándo elegir uno sobre el otro según la tarea.Herramientas y comandos que todo DevOps debería conocer.Cómo mejorar tu eficiencia usando atajos y automatización.

"Si funciona, no lo toques"... ¿o sí? En este episodio de Dev&Ops, Juan y Douglas se sumergen en uno de los enemigos más silenciosos y persistentes de cualquier proyecto: la deuda técnica.Descubre que la deuda técnica es mucho más que código mal escrito. Es una deuda que crece con intereses y que, si no se gestiona, puede paralizar tu desarrollo y tus operaciones. Acompáñanos a explorar por qué es un problema inevitable que afecta tanto a desarrolladores como a la gente de sistemas , y cómo una mala decisión hoy puede costarte muy caro en el futuro.¿Tienes una deuda técnica que parece imposible de pagar? ¡Cuéntanos tu experiencia en los comentarios! No olvides darle like, suscribirte y compartir este episodio con tu equipo.¡Ú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 🎧

🌍 En este episodio de Dev&Ops, Douglas y Juan abordan sin filtros una de las preguntas más comunes para quienes quieren trabajar en IT de forma remota desde Latinoamérica: ¿qué nivel de inglés realmente se necesita?📈 Con anécdotas personales, experiencias reales en entrevistas internacionales y consejos prácticos, este episodio rompe mitos y ofrece una guía honesta sobre cómo enfrentar el idioma como barrera (o como ventaja) en tu carrera tecnológica.🎯 Vas a aprender:Qué nivel de inglés se necesita para entrevistas técnicas y de cultura.Cómo perder el miedo a hablar aunque tu pronunciación no sea perfecta.Consejos para mejorar tu comprensión auditiva en inglés real (el que no está en los cursos).Qué recursos usar para aprender inglés técnico sin pagar un centavo.Qué buscan realmente las empresas cuando contratan talento en LATAM.🛠️ Además, Douglas comparte estrategias y plataformas que pueden ayudarte a practicar y exponerte al inglés todos los días, incluso si tu entorno es completamente en español.💬 Si querés aplicar a trabajos en Estados Unidos, Europa o con startups remotas, este episodio te va a ahorrar meses de dudas y frustraciones.

En este episodio, discutimos una charla de Rob Pike, uno de los creadores del lenguaje de programación Go. A lo largo de la conversación, exploramos temas como la importancia de la planificación y la mejora continua en el desarrollo de software, el diseño intencional, y la promesa de compatibilidad que Go ofrece. En esta conversación, discutims sobre la refactorización, la importancia de la planificación en el desarrollo de software, y las ventajas del lenguaje Go, incluyendo su librería estándar y su enfoque en la concurrencia. También abordamos la necesidad de estandarización en el desarrollo, la humildad en la elección de lenguajes de programación, y la importancia de aprender de los fracasos. A lo largo de la charla, enfatizaremos que no hay un lenguaje superior, sino que cada uno tiene su propósito y que es fundamental tener una mente abierta en el uso de herramientas y tecnologías.Enlaces:Presentación de Rob Pike: https://www.youtube.com/watch?v=yE5Tpp2BSGwEspecificación de Go: https://go.dev/ref/spec¡Ú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 🎧

🎧 En este episodio especial de Dev&Ops, Douglas aborda en solitario un tema clave para cualquier profesional en sistemas, operaciones o desarrollo: ¿Qué hacen realmente un SRE, un DevOps Engineer, un Cloud Engineer y un Platform Engineer?🌐 Con años de experiencia en infraestructura y cultura DevOps, Douglas nos guía por la evolución de estos roles, cómo nacen, en qué se diferencian y qué habilidades necesitas si querés comenzar una carrera en alguno de ellos.🔍 En este episodio aprenderás:Cómo nació el rol de SRE según Google.Qué hace un Cloud Engineer y en qué se diferencia del SRE.Qué son las plataformas internas (IDPs) y qué hace un Platform Engineer.Por qué "DevOps Engineer" se convirtió en un título ambiguo.Consejos prácticos para quienes están comenzando en el mundo de operaciones.🎯 Además, Douglas ofrece una guía concreta con herramientas, tecnologías y habilidades clave para quienes buscan orientar o reorientar su carrera hacia estos caminos.💬 Si alguna vez te preguntaste cuál es tu próximo paso en el mundo de sistemas, este episodio es para vos.

En este episodio de Dev&Ops, Juan y Douglas abordan un tema universal y, a menudo, doloroso en el mundo de la tecnología: los fracasos y los errores. Desde los pequeños fallos hasta los grandes problemas que impactan a equipos enteros, exploramos cómo afrontar esas situaciones difíciles que, lamentablemente, son parte de nuestro camino.Hablamos sobre cómo la decepción y el desánimo son sentimientos normales, pero lo crucial es aprender a salir de ellos y seguir adelante. Douglas comparte un consejo valioso: en lugar de enfocarnos en no equivocarnos (lo cual es imposible), debemos redirigir nuestro esfuerzo a evitar repetir los mismos errores. ¡Esta mentalidad no solo mejora nuestro progreso profesional, sino también nuestro ánimo!Cloudflare incident report: https://blog.cloudflare.com/cloudflare-service-outage-june-12-2025¡Ú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 🎧Los errores son inevitables en el trabajo.Es fundamental dar la cara ante un error.La rendición de cuentas es clave para el aprendizaje.Los post mortem ayudan a evitar errores futuros.Es importante asumir la responsabilidad total de nuestras tareas.Las consecuencias del fracaso deben ser afrontadas con madurez.La comunicación abierta es esencial en un equipo.Los errores pueden afectar a otros, no solo a uno mismo.Prepararse para el fracaso es parte del proceso profesional.La cultura de la empresa influye en cómo se manejan los errores. La rendición de cuentas es clave en el trabajo.Es importante ser proactivo en la comunicación de errores.Las consecuencias de los errores deben ser asumidas con madurez.El humor puede aliviar la tensión en el trabajo.No hay que tomarse las críticas de manera personal.Superar el daño emocional es un proceso necesario.Los fracasos son oportunidades de aprendizaje.Recuperar la confianza tras un error es fundamental.Recordar victorias pasadas ayuda a mantener la motivación.La mentalidad de crecimiento es esencial para el desarrollo personal.📑 Chapters:(00:00) Introducción(01:24) Definiendo "Fracaso" en el Trabajo(11:07) Cómo Afrontar un Fracaso Inmediato(32:20) Consecuencias del Fracaso y Cómo Afrontarlas(35:32) Consecuencias Laborales de los Errores(39:13) Post Mortem: Aprendiendo de los Errores(59:09) Manejo de la Crítica y el Humor en el Trabajo(01:16:13) Lecciones Aprendidas de los Fracasos(01:20:27) El Impacto Emocional de los Errores(01:23:42) Recuperando la Confianza(01:29:52) Recordando Nuestras Victorias01:36:46 Conclusiones y Consejos Finales

En este episodio del podcast Dev&Ops, Douglas y Juan comparten 4 pilares fundamentales para lograr una colaboración efectiva en equipos técnicos de desarrollo, operaciones y QA. 🤝💻Ya sea que trabajes en una startup o en una empresa grande, estos consejos prácticos pueden ayudarte a reducir fricción, mejorar la productividad y evitar errores en producción.🔍 ¿Qué vas a aprender?✅ Cómo definir un Git Workflow claro y adaptable.✅ La importancia del Code Review más allá de encontrar errores.✅ Por qué el QA no es el enemigo y cómo integrarlo mejor al proceso.✅ Qué debe tener un buen CI/CD pipeline moderno.✅ Cómo usar un sistema de tickets de forma estratégica (¡y sin odiarlo!).✅ Y cómo colaborar mejor con Project Managers aunque no sean técnicos.🎯 Un episodio directo, útil y lleno de experiencia real del día a día en IT.Si querés mejorar la cultura de colaboración en tu equipo, este episodio es para vos.📢 ¡No olvidés dejarnos tus comentarios y compartirlo con tus colegas!

En este episodio, Juan y Douglas discutimos sobre los ambientes de desarrollo en la nube, explorando su definición, herramientas disponibles, beneficios y desafíos. También enfatizamos la importancia de la seguridad y la privacidad en el entorno corporativo, así como la necesidad de adaptarse a nuevas tecnologías. También nos preguntamos sobre el futuro del desarrollo en la nube y su relación con la evolución de los dispositivos móviles.

¿Sientes que la tecnología avanza más rápido que tú? 😵‍💫 En este episodio de Dev&Ops, Juan y Douglas te traemos la clave para mantenerte al día en el mundo tech sin sacrificar tu vida personal. Hablamos de por qué es crucial seguir aprendiendo, cómo la motivación es tu mejor aliada y los retos de encontrar ese balance perfecto. ¿Listo para subir de nivel sin quemarte en el intento?

En este episodio, Juan y Douglas discuten cómo conseguir trabajo remoto en empresas de EE.UU., enfatizando la importancia de la preparación profesional y técnica. A lo largo de la conversación, abordan la necesidad de proyectos personales significativos, la relevancia de las pasantías y la experiencia laboral, así como la percepción de las certificaciones en el ámbito tecnológico. Abordan cómo este tipo de empleo puede mejorar tanto la situación económica como el desarrollo profesional. Se enfatiza la necesidad de un buen nivel de inglés y la preparación de un perfil profesional atractivo, especialmente en plataformas como LinkedIn. Además, se habla sobre la construcción de una marca personal y estrategias efectivas para buscar empleo en Estados Unidos, así como la preparación para entrevistas.🔗 Revisa estos Enlaces:Roadmap: https://roadmap.sh/Pluralsight: https://www.pluralsight.com/Remote-friendly companies: https://github.com/remoteintech/remote-jobs