Skip to content
Artwork for DevOps Daily with Fexingo: CI/CD, Kubernetes, and Modern Software Operations

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

Fexingo

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 discuss monitoring strategies, incident response playbooks, infrastructure-as-code trade-offs, and the cultural friction between development velocity and operational stability—always with concrete examples, never with buzzwords. This is the show for engineers, SREs, and platform leads who want to hear two seasoned practitioners argue through the hard choices: when to rewrite vs. patch, how much observability is enough, and how to keep a multi-cloud deployment from becoming a management nightmare. By the end, you'll carry away a sharpened question about your own stack and a new way to think about reliability. #DevOps #CICD #Kubernetes #SiteReliabilityEngineering #PipelineAutomation #InfrastructureAsCode #IncidentResponse #Monitoring #Observability #CloudOperations #ContainerOrchestration #Postmortem #DeploymentStrategy #Technology #FexingoBusiness #BusinessPodcast #SoftwareEngineering #PlatformEngineering Keep every episode free: buymeacoffee.com/fexingo
Play
  • 32 episodes
  • daily
  • Avg 9 min
  • English

Support the show

Goes straight to the publisher. podnod takes nothing.

Counted on this page — what you have heard stays on this device, so it is not something the list can be paged by.
  • S4 · E182
    Yesterday · 9 min

    How GitOps Sync Drift Destroys Production Reliability

    Episodes on Kubernetes and CI/CD often focus on the mechanics of deployment, but we are looking at a subtler failure mode. In this episode, Lucas and Luna examine how silent configuration drift between your Git repository and your live cluster creates...

    • Transcript
  • S4 · E181
    Wednesday · 10 min

    How Sidecar Containers Are Hiding Your True Cloud Costs

    We look at the hidden infrastructure tax of sidecar patterns in Kubernetes. While proxies like Envoy or data collectors add security and observability, they also consume dedicated CPU and memory that often goes unaccounted for in standard cost reports...

    • Transcript
  • S4 · E180
    Tuesday · 13 min

    How Kubernetes Horizontal Pod Autoscaling Fails At Scale

    Horizontal Pod Autoscaling in Kubernetes is often treated as a set-and-forget feature, but at scale it introduces subtle timing issues that can cause cascading failures during traffic spikes. In this episode, we examine the mechanics of HPA’s polling...

    • Transcript
  • S4 · E179
    Monday · 10 min

    Why Your Kubernetes Cluster Is Wasting Compute on Idle Pods

    Most DevOps teams celebrate high cluster utilization, but this approach often hides a silent killer: idle pods. In this episode of DevOps Daily, we examine how aggressive bin-packing in Kubernetes leads to resource starvation during traffic spikes and...

    • Transcript
  • S4 · E178
    Sunday · 10 min

    How GitOps Drift Destroys Production Reliability

    Lucas and Luna examine why infrastructure-as-code fails when human intervention creates silent drift. Using a real-world case where a manual port change bypassed a Terraform state, they show how reconciliation loops mask errors until deployment day. The...

    • Transcript
  • S4 · E177
    Saturday · 12 min

    How Kubernetes Ingress Controllers Leak Memory

    We dig into why modern ingress controllers like NGINX and Traefik silently consume gigabytes of RAM under moderate load. Lucas breaks down the specific mechanics of connection tracking tables and how default configuration values force production clusters...

    • Transcript
  • S4 · E176
    September 4 · 10 min

    How Kubernetes Network Policies Block Traffic Silently

    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...

    • Transcript
  • S4 · E175
    September 3 · 5 min

    How GitLab Runners Are Leaking Cloud Costs

    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...

    • Transcript
  • S4 · E174
    September 2 · 11 min

    How GitOps Sync Drift Destroys Production Reliability

    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...

    • Transcript
  • S4 · E173
    September 1 · 10 min

    Why Your Kubernetes Cost Reports Are Lying To You

    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...

    • Transcript
  • S4 · E172
    August 31 · 9 min

    How Kubernetes Namespace Quotas Trigger Unexpected Failures

    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...

    • Transcript
  • S4 · E171
    August 30 · 9 min

    How Kubernetes Node Pools Can Cost You More Than You Think

    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...

    • Transcript
  • S4 · E170
    August 29 · 10 min

    How Kubernetes Pod Overhead Changes Node Capacity Calculations

    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...

    • Transcript
  • S4 · E169
    August 28 · 10 min

    How Kubernetes Pod Security Admission Blocks Risky Workloads

    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...

    • Transcript
  • S4 · E168
    August 27 · 10 min

    How Kubernetes Service Meshes Hide Network Latency

    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...

    • Transcript
  • S4 · E167
    August 26 · 5 min

    How Kubernetes Persistent Volume Reclamation Causes Data Loss

    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...

    • Transcript
  • S4 · E166
    August 25 · 7 min

    How Kubernetes Controller Manager Flags Affect Cluster Stability

    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...

    • Transcript
  • S4 · E165
    August 24 · 8 min

    How Kubernetes Request Limits Lead to Costly Overprovisioning

    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...

    • Transcript
  • S4 · E164
    August 23 · 8 min

    How Kubernetes ServiceAccount Tokens Leak Across Namespaces

    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...

    • Transcript
  • S4 · E163
    August 22 · 10 min

    How Kubernetes Leader Election Causes Split Brain Failures

    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...

    • Transcript
Showing 1–20 of 32 episodes