Fexingo

DevOps Daily with Fexingo: CI/CD, Kubernetes, and Modern Software Operations

Business EN ↓ 251 episodes

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

Author

Fexingo

Category

Business

Podcast website

www.fexingo.com

Latest episode

Nov 22, 2026

Where to listen?

Podcasts in the app Replaio Radio Coming soon

Podcasts are coming to the app soon. Install now and be the first to see a whole new take on podcasts

Get it on Google Play Install for free Android 10M+ downloads · 4.7+ rating iOS soon

Episodes

Why Kubernetes CronJob Timezone Handling Breaks Schedules 22.07.2026

In this episode of DevOps Daily with Fexingo, Lucas and Luna dive into a surprisingly common failure mode in Kubernetes: CronJob timezone handling. Since Kubernetes 1.22, the CronJob controller treats schedule strings as UTC by default, but many operators assume it honors the node or container timezone. This leads to jobs running hours early or late, especially during daylight saving transitions....

How Kubernetes Watch Events Overload the API Server 21.07.2026

In this episode of DevOps Daily, Lucas and Luna dive into a notoriously overlooked Kubernetes failure mode—API server overload caused by excessive watch events. They break down how controllers, informers, and custom operators all lean on watch-based architectures, and why a single misconfigured watch can cascade into cluster-wide latency or even outages. Through the lens of a real incident at a mi...

How Kubernetes Vertical Pod Autoscaler Recommends Wrong Requests 21.07.2026

Kubernetes Vertical Pod Autoscaler (VPA) is supposed to right-size container resource requests automatically. But in practice, VPA's recommender often suggests CPU and memory values that lead to pod evictions or wasted capacity. Drawing on real incidents from a mid-2026 production cluster running 50 microservices, Lucas and Luna unpack why VPA's default OOM-aware policy can misinterpret short-live...

How Kubernetes StatefulSet Rolling Update Breaks Persistent Volume Claims 20.07.2026

In this episode of DevOps Daily, Lucas and Luna dive into a subtle but destructive Kubernetes pitfall: StatefulSet rolling updates that orphan PersistentVolumeClaims when the pod template changes. Using a real-world incident at a mid-sized fintech, they walk through how a simple image update triggered PVC detachment, stalled the rollout, and left the cluster in an inconsistent state. They explain...

How Kubernetes Service Mesh mTLS Rotation Causes Pod Restarts 20.07.2026

In this episode of DevOps Daily, Lucas and Luna dive into a subtle but dangerous issue in Kubernetes service meshes: automatic mTLS certificate rotation. When the Istio or Linkerd control plane rotates certificates, badly configured sidecar proxies can restart mid-request, causing connection drops, retry storms, and degraded latency. The hosts walk through a real incident at a mid-size fintech whe...

How Kubernetes PodPreset Drove Operator Config Drift 19.07.2026

In this episode of DevOps Daily with Fexingo, Lucas and Luna dig into a forgotten Kubernetes feature: PodPreset. Once hailed as a way to inject configuration into pods automatically, PodPreset was deprecated in 2022 and removed in Kubernetes 1.25. But many clusters still carry its legacy — and that legacy causes config drift that operators never see coming. Lucas explains how PodPreset worked, why...

How Kubernetes PriorityClass Starvation Blocks Node-Level Scheduling 19.07.2026

In this episode of DevOps Daily with Fexingo, Lucas and Luna dive into a subtle but severe Kubernetes anti-pattern: PriorityClass starvation at the node level. They break down a real-world case where a team set a critical batch job's priority too high, causing it to preempt essential daemonsets and system pods, leading to node instability and failed scheduling. Lucas explains how the Kubernetes sc...

Why Kubernetes Ingress Controller Sticky Sessions Break Under Rolling Updates 18.07.2026

In this episode of DevOps Daily, Lucas and Luna investigate a deceptively common Kubernetes failure: when ingress controller session affinity (sticky sessions) silently breaks during rolling updates. They walk through a real incident at a mid-size e-commerce platform where users were suddenly logged out mid-session after a routine deployment. Lucas explains the mechanics — how NGINX ingress contro...

How Kubernetes Audit Logs Expose Silent Security Threats 18.07.2026

In this episode of DevOps Daily, Lucas and Luna dive deep into Kubernetes audit logs—a powerful but often overlooked tool for detecting silent security threats. They walk through a real-world scenario where a cluster was compromised via a misconfigured webhook, and the only clue was buried in the audit log. They explain how to enable audit logging, what to look for (like unexpected impersonation a...

How Kubernetes PodTopologySpread Constraint Silently Degrades Availability 17.07.2026

Lucas and Luna dive into a subtle Kubernetes anti-affinity trap that many teams don't notice until it's too late. The PodTopologySpread constraint — designed to spread pods evenly across failure domains — can actually concentrate pods onto fewer nodes when misconfigured with a low maxSkew value. Lucas explains a real incident at a mid-sized SaaS company where a three-zone cluster with maxSkew=1 ca...

Why Kubernetes PersistentVolume Claims Stall on WaitForFirstConsumer 17.07.2026

Lucas and Luna dig into a deceptively common Kubernetes failure: PersistentVolumeClaims stuck in Pending because the WaitForFirstConsumer binding mode delays volume provisioning until a pod actually consumes the claim. They trace how this interacts with StatefulSets, pod topology spread constraints, and cluster autoscaler to create cascading scheduling deadlocks. The episode walks through a real i...

Why Kubernetes Node Problem Detector Misses Silent Failures 16.07.2026

Lucas and Luna dive into a specific blind spot in Kubernetes cluster observability: the Node Problem Detector (NPD) and how it fails to catch silent hardware and kernel-level issues. They walk through a real incident at a mid-sized fintech where NPD reported 'healthy' while memory corruption was quietly degrading performance across 12 nodes. They explain why default NPD configurations only monitor...

How Kubernetes ConfigMap Rollouts Silently Fail Without Immutable Fields 16.07.2026

In this episode of DevOps Daily with Fexingo, Lucas and Luna dive into a hidden Kubernetes failure mode: when ConfigMap updates are rolled out to Deployments, but the Pods never pick up the new data because the rollout trigger is missing. They walk through a real incident from a mid-sized fintech where a database connection string changed at 2 AM, the ConfigMap was updated, but the Deployment neve...

How Kubernetes Priority Class Starvation Locks Down Clusters 15.07.2026

In this episode of DevOps Daily, Lucas and Luna dive into a subtle but dangerous Kubernetes problem: priority class starvation. When lower-priority pods are preempted but never actually evicted due to PDB constraints, the scheduler gets stuck in a loop, and the cluster can grind to a halt. They walk through a real scenario where a team's production deployment failed because a single PriorityClass...

How Kubernetes Downward API Labels Break Pod Identity 15.07.2026

Lucas and Luna dig into a surprisingly brittle Kubernetes footgun: using the Downward API to inject pod labels as environment variables. They walk through a real incident where a label change triggered cascading failures because application code was hard-wired to read pod name from an env var that silently went stale. The conversation covers why this pattern is so common in Helm charts, how it dif...

Why Kubernetes Service Mesh Sidecar Injection Latency Matters 14.07.2026

In this episode of DevOps Daily, Lucas and Luna explore how service mesh sidecar injection in Kubernetes can introduce surprising latency during pod startup. They break down the mechanics of Istio's mutating webhook, explain why a 30-second delay in sidecar readiness can cascade into failed health checks and rolling update blips, and share practical mitigation strategies. Using a real deployment e...

How Kubernetes Network Policies Can Leak Pod Traffic 14.07.2026

Most teams assume Kubernetes Network Policies provide airtight segmentation. In this episode, Lucas and Luna break down a specific flaw: how a misconfigured egress policy combined with a default-deny-all ingress rule can actually leak DNS and API traffic to unintended namespaces. They walk through a real incident at a mid-sized fintech where a missing podSelector allowed a payments microservice to...

How Kubernetes Mutating Admission Webhooks Cause Cascade Failures 13.07.2026

When a single misbehaving mutating admission webhook in Kubernetes can take down your entire cluster, it's not just a developer headache—it's a production emergency. In this episode, Lucas and Luna break down the real-world cascade failure at a major fintech that lost $2.3 million in trading revenue over 47 minutes. They walk through how webhooks work, why a simple config map change triggered a ch...

How Kubernetes ResourceQuota Silent Denials Break Deployments 13.07.2026

In this episode of DevOps Daily with Fexingo, Lucas and Luna tackle a frustratingly common Kubernetes pitfall: ResourceQuota silent denials. When a namespace's ResourceQuota is hit, the API server rejects resource creation without a clear error — often leaving teams debugging cryptic 'Internal error occurred' messages or watching pods hang in Pending. We walk through a real incident at a mid-size...

Why Kubernetes CPU Limits Misconfigure HPA Scaling 12.07.2026

Episode 107 dives into a common misconfiguration: setting CPU limits on Kubernetes pods that unintentionally cap the Horizontal Pod Autoscaler's ability to scale. Lucas and Luna explore how the relationship between resource requests and limits affects the HPA algorithm, using a real-world example from a FinTech startup that saw scaling delays of over 40 seconds. They explain why the default CPU li...

How Kubernetes Pod Disruption Budgets Cause Cascading Failures 12.07.2026

In this episode, Lucas and Luna dive into a counterintuitive Kubernetes failure mode: correctly configured PodDisruptionBudgets that actually create cascading availability failures. Using a real-world example from a large e-commerce platform migrating to spot instances in July 2026, they explain how PDBs interact with cluster autoscaler taint-based evictions and node drain logic to deadlock worklo...

How Docker Image Layer Caching Slows CI Pipelines 11.07.2026

Episode 105 of DevOps Daily dives into a surprising CI bottleneck: Docker image layer caching that backfires. Lucas and Luna examine how layer reuse assumptions break down in environments with dynamic dependency trees, leading to cache-miss avalanches and pipeline slowdowns. They walk through a real case study from a mid-size e-commerce team that saw CI times balloon from 8 to 22 minutes after ado...

How Docker Image Layer Caching Slows CI Pipelines 11.07.2026

Lucas and Luna dissect a specific CI/CD failure pattern: Docker image layer caching that actually degrades pipeline performance. Using a real-world example of a mid-stage startup whose builds went from 4 minutes to 22 minutes after adopting a naive cache strategy, they explain layer invalidation, cache-miss cascades, and the trade-off between cache reuse and build determinism. Lucas walks through...

How Kubernetes Pod Overhead Misconfiguration Causes Node Resource Exhaustion 10.07.2026

In this episode of DevOps Daily, Lucas and Luna dive into a subtle but dangerous Kubernetes configuration trap: pod overhead misassignment. When cluster operators set pod overhead values incorrectly—especially in clusters running multiple sandboxed runtimes like Kata Containers or gVisor—the kubelet can overcommit node resources, leading to unexplained OOM kills and node pressure. Lucas walks thro...

How Kubernetes Vertical Pod Autoscaler Can Destabilize Workloads 10.07.2026

Episode 102 of DevOps Daily dives into a lesser-known risk with Kubernetes Vertical Pod Autoscaler (VPA): its ability to cause cascading instability in production workloads. Lucas and Luna walk through a real-world case where VPA's recommender triggered simultaneous resource resizing across multiple microservices, leading to pod evictions, request timeouts, and a multi-hour incident at a mid-sized...

Listen to the DevOps Daily with Fexingo: CI/CD, Kubernetes, and Modern Software Operations podcast in Replaio

Radio and podcasts in one app - free, with no sign-up. Install today and do not miss the launch

Get it on Google Play

Replaio is not a podcast publisher; show names, artwork and audio belong to their authors and are distributed through public RSS feeds.