Fexingo
DevOps Daily with Fexingo: CI/CD, Kubernetes, and Modern Software Operations
Lucas and Luna dissect the daily realities of DevOps, from CI/CD pipeline design to Kubernetes cluster management and the human systems that keep software running. Each episode grounds abstract principles in real incidents—a failed deployment at a major retailer, a postmortem from a cloud outage, a configuration drift disaster—and traces the operational decisions that turned them around. Lucas brings the technical precision of a working engineer, while Luna pushes on the team dynamics, cost trade-offs, and organizational bottlenecks that separate resilient operations from fragile ones. They di...
Be sure to visit the podcast's website and support the creator: www.fexingo.com
Where to listen?
Podcasts in the app Replaio Radio Coming soonPodcasts are coming to the app soon. Install now and be the first to see a whole new take on podcasts
Episodes
How Kubernetes Network Policies Block Traffic Silently 04.09.2026 10:21
Most teams treat Kubernetes NetworkPolicies as optional security add-ons, but they are actually the primary traffic controller for your microservices. When misconfigured, they don't just fail open; they fail closed, causing silent DNS resolution errors and cascading timeouts that look like application bugs rather than infrastructure issues. We break down a specific case where a missing egress rule...
How GitLab Runners Are Leaking Cloud Costs 03.09.2026 5:05
Most engineering teams treat their CI/CD runners as infinite resources, but this episode examines how ephemeral runner sprawl in GitLab and GitHub Actions is quietly inflating cloud bills by up to thirty percent. We look at a specific case where a mid-sized SaaS company reduced its monthly compute spend by forty thousand dollars simply by tuning idle timeout settings and restricting runner scope....
How GitOps Sync Drift Destroys Production Reliability 02.09.2026 11:48
Most teams treat Git as the source of truth, but in practice, manual fixes and emergency patches create a dangerous gap between what is committed and what is running. This episode explores how sync drift accumulates silently until it causes catastrophic outages, using a specific case where a three-character configuration change bypassed code review and took down a payment service for four hours. W...
Why Your Kubernetes Cost Reports Are Lying To You 01.09.2026 10:58
Most engineering teams believe their cloud bills are accurate because they rely on default Kubernetes resource requests. But those numbers are often just guesses made months ago, leading to massive overprovisioning and hidden waste. In this episode of DevOps Daily, we look at a specific case study where a mid-sized fintech startup discovered that forty percent of their cluster spend was allocated...
How Kubernetes Namespace Quotas Trigger Unexpected Failures 31.08.2026 9:54
In Episode 172 of DevOps Daily, Lucas and Luna drill into a deceptively simple Kubernetes feature: namespace resource quotas. When a namespace hits its quota, pods fail to schedule and existing workloads can be evicted. Using a real-world example of a production outage caused by a misconfigured ResourceQuota, they explain how Kubernetes calculates quota usage, why the system doesn't always behave...
How Kubernetes Node Pools Can Cost You More Than You Think 30.08.2026 9:13
In episode 171 of DevOps Daily, Lucas and Luna dig into the hidden costs of Kubernetes node pools — not the hardware bills, but the operational and architectural costs that show up months later. Lucas walks through a real case study of a startup that split its workloads into separate pools for 'isolation' and ended up with double the management overhead, unpredictable bin-packing, and a painful mi...
How Kubernetes Pod Overhead Changes Node Capacity Calculations 29.08.2026 10:05
In this episode of DevOps Daily, Lucas and Luna dig into Kubernetes pod overhead — the CPU and memory each pod consumes before your container even starts. They walk through a real scenario where a cluster's node capacity looked fine on paper but ran out of resources during a rolling deployment. Lucas explains how the kubelet accounts for pod overhead, why the kubelet's eviction signals can trigger...
How Kubernetes Pod Security Admission Blocks Risky Workloads 28.08.2026 10:26
In episode 169 of DevOps Daily, Lucas and Luna dive into Kubernetes Pod Security Admission (PSA) and the three built-in policies: privileged, baseline, and restricted. They walk through a real incident where a seemingly innocent deployment broke after PSA was enabled, examine how exemptions can silently weaken the guardrails, and discuss why moving to restricted is harder than it looks. With PSA n...
How Kubernetes Service Meshes Hide Network Latency 27.08.2026 10:28
In this episode, Lucas and Luna dig into a frustrating Kubernetes mystery: a service mesh that quietly added latency to every request without triggering any alarms. They walk through a real-world incident where mTLS handshakes and sidecar proxies doubled p99 response times, yet dashboards showed everything green. The conversation covers how to spot the hidden cost of service meshes, why metrics li...
How Kubernetes Persistent Volume Reclamation Causes Data Loss 26.08.2026 5:59
In this episode of DevOps Daily, Lucas and Luna dig into a surprisingly common Kubernetes failure: the PersistentVolumeReclaimPolicy. When a PersistentVolumeClaim is deleted, the default 'Delete' policy can erase the underlying storage — and your data — before you realize what happened. Lucas walks through a real incident where a single accidental PVC deletion nuked three production databases beca...
How Kubernetes Controller Manager Flags Affect Cluster Stability 25.08.2026 7:41
In this episode of DevOps Daily, Lucas and Luna dissect the Kubernetes controller manager's flags that often go overlooked, leading to subtle stability issues. They explore how misconfigured flags like --concurrent-syncs and --node-monitor-period can cause cascading failures in large clusters, drawing from real-world operational incidents. The discussion highlights the importance of understanding...
How Kubernetes Request Limits Lead to Costly Overprovisioning 24.08.2026 8:53
In this episode of DevOps Daily, Lucas and Luna dig into a surprisingly common Kubernetes misstep: setting CPU and memory requests too high. Using a real-world example from a mid-sized fintech that saw its cloud bill jump 40 percent after a migration, they explain how requests and limits work, why overprovisioning sneaks in, and the hidden costs that follow. They walk through the mechanics of the...
How Kubernetes ServiceAccount Tokens Leak Across Namespaces 23.08.2026 8:02
In Episode 164 of DevOps Daily, Lucas and Luna dig into a subtle Kubernetes security gap: ServiceAccount tokens that silently travel across namespace boundaries. They walk through a real incident where a CI/CD pipeline mounting a token in one namespace accidentally exposed it to workloads in another, and explain how token volume projection and RBAC misconfigurations can turn a simple deploy into a...
How Kubernetes Leader Election Causes Split Brain Failures 22.08.2026 10:39
In this episode of DevOps Daily, Lucas and Luna dive deep into a common yet often overlooked failure mode in Kubernetes: leader election. When the kube-controller-manager's leader election fails, it can lead to split-brain scenarios where multiple controllers act simultaneously, causing race conditions and cascading errors. We explore a real incident where a misconfigured lease duration and renew...
How Kubernetes Pod Security Contexts Cause Permission Headaches 21.08.2026 7:48
In this episode of DevOps Daily, Lucas and Luna dig into the surprisingly common but often misunderstood world of Kubernetes Pod Security Contexts. They use a real-world case of a microservice that kept failing with permission errors after an update to show how securityContext settings interact with container images, volumes, and admission controllers. You'll learn why setting the right user ID an...
How Kubernetes Metrics Server Latency Breaks HPA Scaling 20.08.2026 7:30
In this episode of DevOps Daily, Lucas and Luna dig into a deceptively simple failure mode: the Kubernetes Metrics Server takes a few extra seconds to return pod metrics, and the Horizontal Pod Autoscaler overreacts. They walk through a real incident where a 45-second metrics delay caused wild replica swings, wasted cloud spend, and a brief outage. Lucas explains how the HPA's default tolerance wi...
How Kubernetes Finalizers Locked Our Namespace for Three Weeks 19.08.2026 7:33
In Episode 160 of DevOps Daily, Lucas and Luna drill into a deceptively simple Kubernetes footgun: object finalizers and namespace deletion. When a team at a mid-sized fintech tried to clean up a failed release, a single finalizer on a custom resource (CRD) silently held the namespace in 'Terminating' for three weeks. The episode walks through exactly how finalizers work under the hood, why the na...
How Kubernetes Object Finalizers Block Namespace Deletion 18.08.2026 8:06
In this episode of DevOps Daily, Lucas and Luna dig into a surprisingly common Kubernetes headache: namespaces stuck in the Terminating state because of object finalizers. They walk through a real incident where a single stuck custom resource with a finalizer held up an entire namespace deletion, blocking a whole environment teardown and causing pipeline failures. You'll learn what finalizers actu...
Why Kubernetes Pods Restart When Nodes Reboot 17.08.2026 12:02
When a Kubernetes node reboots for a kernel update or hardware maintenance, pods don't just vanish and come back cleanly. The kubelet marks them as terminated, the container runtime loses state, and what looks like a routine maintenance window turns into failed readiness probes, stuck terminating pods, and a cascade of restarts. In episode 158 of DevOps Daily, Lucas and Luna break down the actual...
How Kubernetes Node Journal Rotation Hides Crash Loops 16.08.2026 8:55
In this episode of DevOps Daily, Lucas and Luna dig into a silent killer in Kubernetes clusters: systemd journal rotation. When the kubelet's logs are rotated out before a crash is captured, debugging becomes guesswork. They walk through the mechanics of journald's size and time-based rotation, the systemd-journald daemon's default rate limits, and how a busy cluster can lose critical kubelet logs...
How Kubelet Eviction Signals Trigger Silent Pod Deaths 15.08.2026 11:46
In this episode of DevOps Daily, Lucas and Luna dig into a classic Kubernetes failure mode: kubelet eviction signals that silently kill pods. The trigger is often memory pressure on the node, and the fallout is worse than a crash — the pod vanishes without a proper termination, leaving no time for graceful shutdown. They walk through a real-world scenario from an e-commerce platform where the memo...
How Kubernetes HPA Fails When Custom Metrics Lag 14.08.2026 8:54
In this episode of DevOps Daily, Lucas and Luna dive into the hidden pitfalls of Horizontal Pod Autoscaler (HPA) with custom metrics. They explore a real-world incident where a stale external metric from a monitoring system caused the HPA to scale down a critical service during a traffic spike, leading to degraded performance and a cascade of alerts. The discussion covers how HPA evaluates metrics...
Why Your Kubernetes Cluster DNS Queries Are Slow 13.08.2026 7:44
In this episode, Lucas and Luna dive into a frequent but often misunderstood Kubernetes performance issue: slow cluster DNS queries. They unpack how CoreDNS, the default DNS server, can become a bottleneck when node-level caching is missing, and why adding NodeLocal DNSCache often resolves latency spikes. With a concrete example from a payments company that saw p99 DNS latency drop from 120ms to u...
How Kubelet CPU Manager Policies Cause Pod Performance Variability 12.08.2026 10:49
In this episode of DevOps Daily, Lucas and Luna dive into a subtle but impactful Kubernetes issue: CPU manager policies. They explore how the default 'none' policy can lead to unpredictable performance due to CPU cache contention and context switching, and how the 'static' policy can guarantee exclusive cores but introduces its own pitfalls, like the risk of pods being stuck on specific nodes. Usi...
How Kubernetes Pod Disruption Budgets Cause Node Drain Stalls 11.08.2026 9:23
In this episode of DevOps Daily, Lucas and Luna dig into Kubernetes Pod Disruption Budgets and why they are a common culprit behind node drain stalls. They walk through a real-world scenario where a PDB with minAvailable set too high prevented a node from being drained, causing a cascade of failed evictions and stuck deployments. The conversation covers the difference between minAvailable and maxU...
Similar podcasts
Replaio is not a podcast publisher; show names, artwork and audio belong to their authors and are distributed through public RSS feeds.