DevOps Academy Podcast

DevOps Academy Podcast

by Ivo Radulovski
Season 1

DevOps Academy S1E21: Shadow AI Is Becoming the New Shadow IT — Do You Know What Agents Are Running in Your Organization?

AI
Your engineering team may be using more AI tools than you realize. But do you know which ones have access to your code, credentials, and production systems? From AI coding assistants and locally running models to autonomous agents and unofficial automations, Shadow AI is becoming a growing challenge for engineering organizations. Developers are adopting AI tools to move faster, but many of these tools operate outside traditional IT approval processes, security monitoring, and governance frameworks. In this episode of DevOps Academy Deep Dive, we explore how Shadow AI is evolving beyond unapproved chatbots into AI agents that can access repositories, interact with infrastructure, process sensitive information, and execute recurring workflows. We discuss the risks of unmanaged AI tools, hidden credentials, unknown dependencies, and agents that quietly become part of production operations. We also examine how DevOps, platform engineering, and security teams can gain visibility into AI adoption without restricting innovation or slowing developers down. 🔑 Key Takeaways What Shadow AI is and how it differs from traditional Shadow IT Why AI agents create new visibility and governance challenges How unofficial AI tools gain access to repositories, credentials, and infrastructure The risks of unmanaged AI agents running automated workflows How organizations can discover and inventory AI tools When an AI experiment becomes an operational dependency The hidden costs of duplicate AI tools and fragmented adoption The importance of approved AI tool catalogs and clear ownership Why high-impact AI agents need independent shutdown controls How to bring useful unofficial AI tools into managed environments Balancing developer innovation with security and operational accountability 🎧 Tune in to discover why the biggest AI security risk may not be the agents your organization has approved, but the ones it doesn't even know exist. 💬 If you had to identify every AI agent accessing your company's systems tomorrow, could you?

DevOps Academy S1E20: MCP in Production — Are AI Agents Creating a New Infrastructure Security Boundary?

AI
AI agents are moving beyond generating answers. They're connecting to real infrastructure, accessing internal systems, and interacting with production environments. But who controls what they're allowed to do? The Model Context Protocol (MCP) is making it easier for AI applications to connect with external tools, from Kubernetes clusters and cloud platforms to databases, monitoring systems, and CI/CD pipelines. While these integrations open up new possibilities for DevOps automation, they also introduce important security challenges. In this episode of DevOps Academy Deep Dive, we explore what happens when AI assistants gain access to production infrastructure and why traditional security controls need to be carefully enforced across these new connections. We discuss MCP server permissions, prompt injection, authentication, authorization, credential handling, and the risks of giving AI agents excessive access. We also examine how DevOps teams can design secure MCP integrations without sacrificing the benefits of AI-assisted engineering. 🔑 Key Takeaways What MCP is and why it matters for DevOps and infrastructure How AI agents interact with production systems through MCP servers Why MCP introduces new infrastructure access and security considerations The risks of overprivileged MCP servers and service accounts How prompt injection can influence AI-driven infrastructure operations Why read-only access doesn't always mean risk-free access Authentication vs. authorization in MCP integrations Why narrowly scoped MCP tools are safer than unrestricted command execution The role of human approval in sensitive production operations How to audit and trace AI-initiated infrastructure changes How to test MCP integrations before production deployment Why least privilege and independent authorization are essential for AI agents 🎧 Tune in to discover how MCP is changing the way AI interacts with infrastructure—and what DevOps teams need to consider before giving AI agents access to production systems. 💬 Would you trust an AI agent with access to your production infrastructure?

DevOps Academy Deep Dive S1E19: AI Workloads Fail Differently — Is Traditional SRE Enough for Production AI?

AI
What happens when your AI application is running perfectly, but its answers are wrong? Traditional Site Reliability Engineering focuses on availability, latency, error rates, and infrastructure performance. But production AI introduces a new challenge: a system can be technically healthy while delivering unreliable results. In this episode of DevOps Academy Deep Dive, we explore why AI workloads require a broader approach to reliability engineering. From hallucinations and model drift to inference latency, retrieval failures, and unpredictable outputs, we discuss the challenges of keeping AI-powered applications dependable in production. We also examine how SRE teams can adapt service-level objectives (SLOs), monitor AI output quality, manage model-provider failures, and design fallback strategies that protect the user experience. 🔑 Key Takeaways Why AI applications fail differently from traditional software The difference between infrastructure reliability and AI output quality Why successful API responses don't guarantee successful outcomes How to define meaningful SLOs for production AI systems Measuring model accuracy, task completion, and response quality Understanding model drift and silent quality regressions Why inference latency requires different performance metrics GPU capacity planning and AI workload scaling challenges Monitoring retrieval-augmented generation (RAG) applications How to safely deploy, evaluate, and roll back AI model updates Why continuous evaluation matters after deployment How SRE and machine-learning teams can collaborate on AI reliability 🎧 Tune in to discover why keeping AI systems available is only half the challenge, and what it takes to make them truly reliable. 💬 If your AI application returns 200 OK but gives the wrong answer, is it really working?

DevOps Academy Deep Dive S1E18: AI Is Making Developers Faster — Is Infrastructure Becoming the New Bottleneck?

AI
AI coding assistants are helping developers write code, generate tests, and build applications faster than ever. But is the rest of the software delivery process keeping up? In this episode of DevOps Academy Deep Dive, we explore how AI-assisted development is shifting engineering bottlenecks from writing code to infrastructure provisioning, CI/CD pipelines, security reviews, testing, and production operations. We discuss why faster code generation doesn't automatically mean faster software delivery, how AI-generated infrastructure can introduce new complexity, and why platform engineering, self-service capabilities, and automation are becoming increasingly important. 🔑 Key Takeaways Why faster coding doesn't always mean faster software delivery How AI shifts bottlenecks into infrastructure, CI/CD, and security The growing gap between AI-generated code and human review capacity Why AI-generated infrastructure requires architectural oversight How platform engineering and golden paths can reduce friction Why self-service infrastructure matters more in AI-assisted development How increased development speed affects testing and deployment pipelines The hidden maintenance costs of rapidly generated software Why engineering teams should measure end-to-end delivery performance How DevOps teams can identify and eliminate the next bottleneck 🎧 Tune in to discover why the biggest challenge in AI-assisted development may no longer be writing code, but building engineering systems that can keep up. 💬 Is AI making your engineering team faster, or simply moving the bottleneck somewhere else?

DevOps Academy Deep Dive S1E16: eBPF and the Future of Observability — Can We Monitor Systems Without Instrumenting Everything?

AI
Modern engineering teams collect more telemetry than ever, yet getting meaningful visibility into production can still require extensive application instrumentation. In this episode of DevOps Academy Deep Dive, we explore how eBPF is changing observability by providing deeper visibility into running systems without requiring developers to modify every application. We discuss where eBPF fits alongside traditional instrumentation and OpenTelemetry, how it can help uncover service dependencies and performance problems, and why automatic observability doesn't mean collecting everything. The conversation also looks at continuous profiling, Kubernetes environments, AI-assisted troubleshooting, security, privacy, and the limits of zero-code instrumentation. 🔑 Key Takeaways What eBPF is and why it matters for DevOps and SRE teams How eBPF provides visibility without modifying application code Where traditional application instrumentation is still necessary Why technical visibility and business context are different How eBPF can help uncover real service dependencies Why it can be especially valuable for legacy and third-party applications How continuous profiling adds deeper performance context Where eBPF and OpenTelemetry complement each other How AI could correlate runtime telemetry and accelerate troubleshooting Why the future of observability is likely a combination of automatic discovery and intentional instrumentation 🎧 Tune in to explore whether the next generation of observability will require developers to instrument less while still understanding production more deeply. 💬 Could your team understand production without manually instrumenting every service?

DevOps Academy Deep Dive S1E16: When Incidents Last for Days — Are DevOps Teams Prepared for the Long Outage?

AI
Most incident response plans are built around the first few hours of an outage. But what happens when the incident continues into the next shift, the next time zone, or even the next day? In this episode of DevOps Academy Deep Dive, we explore the challenges of long-running production incidents and why they test much more than technical recovery. From responder fatigue and shift handoffs to decision logs, changing hypotheses, stakeholder communication, and organizational single points of failure, we look at what it takes to keep an incident response effective when the original team can no longer stay online. 🔑 Key Takeaways Why long-running incidents require a different response strategy How responder fatigue becomes an operational risk Why incident teams need structured shift handoffs What should be captured in a live incident document and decision log How to prevent new responders from repeating previous investigations Why incident command may need to rotate How to balance mitigation with root-cause investigation Why long outages expose knowledge and ownership gaps Where AI can help preserve incident context and prepare handoffs Why incident exercises should test people and processes, not just systems How to manage temporary emergency changes after recovery Why resilient incident response should never depend on individual heroics 🎧 Tune in to explore how DevOps and SRE teams can prepare for the incidents that don't end after the first few hours. 💬 Could your incident response process survive a complete shift change without losing critical context?

DevOps Academy Deep Dive S1E15: Who Owns Production Now? DevOps, SRE, Platform Teams—or Developers?

AI
As engineering organizations become more specialized, production ownership is getting harder to define. Should developers own what they build? Should SRE teams own reliability? Should platform teams own the runtime environment? Or should DevOps remain the connective layer across everything? In this episode of DevOps Academy Deep Dive, we explore how modern engineering teams divide responsibility for production—and where unclear ownership creates delays, bottlenecks, and incident confusion. The conversation looks at shared responsibility, service ownership, on-call, platform engineering, SRE, self-service infrastructure, Infrastructure as Code, incident response, and the growing role of AI in operational workflows. 🔑 Key Takeaways Why production ownership should be shared but never ambiguous What “you build it, you run it” really means Why central DevOps teams can become operational bottlenecks How platform engineering changes the ownership model Where SRE fits into production reliability Why application teams still need operational accountability How clear incident roles reduce confusion during outages How self-service platforms support distributed ownership How AI can automate operations without taking over responsibility Why autonomy must come with guardrails and clear ownership boundaries 🎧 Tune in to explore how modern teams can distribute production responsibility without creating uncertainty over who owns what. 💬 Who owns production in your organization today?

DevOps Academy Deep Dive S1E14: FinOps Meets DevOps — Should Engineers Be Accountable for the Cloud Bill?

AI
Cloud infrastructure is easier than ever to provision, scale, and automate. But with that flexibility comes a growing challenge: who is responsible for the cost? In this episode of DevOps Academy Deep Dive, we explore where FinOps and DevOps intersect, and why cloud economics is becoming an increasingly important part of modern engineering. The conversation looks at how engineers can balance performance, reliability, and cost without turning FinOps into a simple cost-cutting exercise. We discuss unit economics, Kubernetes cost allocation, Infrastructure as Code, platform engineering, AI workloads, observability spending, and the role of automation in identifying cloud waste. 🔑 Key Takeaways Why cloud cost is becoming an engineering concern The difference between cost reduction and cost efficiency How unit economics can make cloud spending more meaningful Why unused capacity is not always waste How overprovisioning, idle resources, storage, and telemetry increase costs Why Kubernetes can make cost attribution more difficult How Infrastructure as Code can bring cost awareness into code review 🎧 Tune in to explore why the future of DevOps is not just about shipping faster and staying reliable, but also about understanding whether infrastructure spending makes sense for the value it creates. 💬 Should DevOps engineers be responsible for the cloud bill, or should cost remain a finance concern?

DevOps Academy Deep Dive S1E13: Software Supply Chain Security — Can We Still Trust Open Source?

AI
Modern software is built on open source—but how much do we really know about the code, packages, container images, and CI/CD components entering our production environments? In this episode of DevOps Academy Deep Dive, we explore the growing challenge of software supply chain security and what DevOps teams can do to move from blind trust toward verifiable trust. The conversation looks beyond vulnerability scanning to examine the entire path from source code to production—including dependencies, compromised packages, SBOMs, artifact provenance, signing, container security, CI/CD permissions, and the emerging impact of AI-generated code. 🔑 Key Takeaways Why software dependencies have become a major security challenge How compromised and malicious packages can enter the supply chain What an SBOM tells you—and what it doesn't The difference between SBOMs and software provenance Why artifact signing matters before software reaches production How CI/CD pipelines can become a critical attack surface Why third-party actions and plugins should be treated as dependencies How DevOps can move from blind trust to verifiable trust 🎧 Tune in to explore how engineering teams can continue benefiting from open source without treating every dependency as automatically trustworthy. 💬 How confident are you that your team knows exactly what's inside the software you're shipping?

DevOps Academy Deep Dive S1E12: The Future of On-Call — Can AI Finally End Alert Fatigue?

AI
It's 2 AM, your phone goes off, and another production alert demands attention. But what if AI could determine whether you actually need to wake up? In this episode of DevOps Academy Deep Dive, we explore how AI could transform one of the most stressful parts of DevOps and Site Reliability Engineering: on-call operations and alert fatigue. From correlating hundreds of alerts into a single incident to analyzing logs, identifying recent deployments, retrieving runbooks, and recommending remediation, AI is creating new possibilities for smarter incident response. But how much control should we give it? We discuss the shift from traditional threshold-based monitoring toward intelligent, context-aware operations—and why the future may not be about eliminating on-call entirely, but ensuring engineers are interrupted only when human judgment is genuinely required. 🔑 Key Takeaways Why alert fatigue remains a major DevOps and SRE challenge How AI can correlate, deduplicate, and prioritize alerts Using AI to accelerate root-cause investigation How historical incidents and runbooks can improve AI-assisted response When autonomous remediation makes sense—and when it doesn't Why SLOs and good observability become even more important with AI How AI can identify noisy and ineffective alerts The risks of giving incident agents production access How AI could reduce on-call burnout without removing human expertise Why the future could shift from alert-driven to exception-driven operations 🎧 Tune in to discover how AI could transform incident response—and whether the 2 AM production page could eventually become the exception rather than the norm. 💬 Would you trust AI to automatically resolve a production incident without waking the on-call engineer?
1 of 3