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

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

By FexingoBusiness
Download on the App Store

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

  • Why Your Kubernetes Cluster Needs Network Policies

    Lucas and Luna dive into Kubernetes network policies — a critical but often overlooked security layer. They explain why default 'allow all' traffic is risky, how a single misconfigured policy can expose your cluster, and walk through a real-world example from a fintech startup that locked down its microservices. Listeners will learn the three essential network policy rules every DevOps team should implement, plus how to test policies without breaking production. No fluff, just actionable insights for anyone running containers in production.

    #Kubernetes #NetworkPolicies #DevOps #ContainerSecurity #CloudNative #Microservices #Fintech #Security #Calico #Cilium #PodSecurity #TrafficControl #Tech #FexingoBusiness #BusinessPodcast #DevOpsDaily #ZeroTrust #K8sBestPractices

    Keep every episode free: buymeacoffee.com/fexingo

    8 min
  • Why Your Kubernetes Pod Security Policies Are Outdated

    Lucas and Luna dive into why Kubernetes Pod Security Policies are being deprecated and what Pod Security Admission replaces them with. They break down the practical impact on DevOps teams, how to migrate without breaking production, and why the old approach created more work than security. If you're still using PSPs or have avoided updating, this episode gives you the migration playbook.

    #Kubernetes #PodSecurityAdmission #DevOps #CloudNative #ContainerSecurity #PodSecurityPolicies #K8sSecurity #InfrastructureAsCode #Technology #BusinessPodcast #FexingoBusiness #DevOpsDaily #SecurityShift #K8sMigration #PSP #AdmissionController #ClusterSecurity #DevSecOps

    Keep every episode free: buymeacoffee.com/fexingo

    10 min
  • Why Your Helm Charts Are a Security Risk

    In this episode of DevOps Daily, Lucas and Luna dig into a surprisingly common blind spot in Kubernetes deployments: misconfigured Helm charts that leak secrets, expose ports, or grant overly broad RBAC permissions. They walk through a real incident from a fintech startup that lost $12,000 in crypto mining costs because a Helm chart default exposed their cluster's metadata API. Lucas explains why the 'helm template' command should be part of every CI pipeline, and Luna shares how her team caught similar issues by scanning chart output before apply. If you deploy with Helm, this episode will change how you review your charts. No ads, just practical DevOps.

    #Helm #Kubernetes #DevOps #Security #SecretManagement #RBAC #CICD #InfrastructureAsCode #CloudNative #KubernetesSecurity #HelmCharts #DevSecOps #Technology #FexingoBusiness #BusinessPodcast #DevOpsDaily #Podcast #TechOps

    Keep every episode free: buymeacoffee.com/fexingo

    10 min
  • Why Your Secret Scanning Pipeline Should Run Before CI

    Episode 6 of DevOps Daily with Fexingo tackles a common but dangerous assumption in modern CI/CD: that security scanning should happen after tests pass. Lucas and Luna walk through a real September 2025 incident at a fintech startup where a leaked AWS key in a public repo wasn't caught until 47 minutes after merge. They explain why shifting secret scanning to pre-commit hooks and pre-CI gates — with tools like Gitleaks, TruffleHog, and custom regex — prevents blast radius damage. The hosts debate trade-offs: developer friction versus runtime detection, false positive fatigue, and how to track scan coverage with a simple Service Level Objective. They also cite a 2025 GitGuardian report showing a 62 percent year-over-year increase in exposed credentials. The episode ends with a concrete three-step implementation checklist any team can adopt this week. No jargon for jargon's sake — just a focused case and a clear, actionable argument for changing when you scan.

    #SecretScanning #CI/CD #DevSecOps #Gitleaks #TruffleHog #GitGuardian #PreCommitHooks #SecurityPipeline #FintechSecurity #CloudSecurity #InfrastructureAsCode #ShiftLeft #ServiceLevelObjective #FalsePositive #DeveloperExperience #Technology #FexingoBusiness #BusinessPodcast

    Keep every episode free: buymeacoffee.com/fexingo

    10 min
  • Why Your Infrastructure Code Needs a Linter

    Lucas and Luna dive into infrastructure-as-code linting—why most DevOps teams skip it and why that's a costly mistake. Lucas walks through a specific case: how HashiCorp's Sentinel policy-as-code framework caught a misconfigured Terraform module that would have exposed an entire production database. They discuss static analysis tools like Checkov and tfsec, the difference between linting and policy enforcement, and why integrating these checks into CI/CD pipelines can cut incident response time by half. Luna pushes back on the overhead argument, and Lucas counters with data showing that teams using IaC linters resolve misconfigurations 60% faster. The episode closes with a practical tip: start with your top five security rules before scaling up.

    #InfrastructureAsCode #Terraform #Linting #DevOps #CI/CD #PolicyAsCode #Security #Checkov #Tfsec #Sentinel #HashiCorp #Automation #CloudEngineering #ConfigurationManagement #DevSecOps #Technology #FexingoBusiness #BusinessPodcast

    Keep every episode free: buymeacoffee.com/fexingo

    8 min
  • Why Observability Needs a Service Level Objective

    Lucas and Luna discuss how service level objectives (SLOs) are transforming DevOps observability. Using a case study from a mid-size e-commerce platform that cut incident response time by 40% after adopting SLO-based alerting, they explain the difference between SLIs, SLOs, and SLAs, and why measuring what matters beats monitoring everything. They also touch on the 'error budget' concept and how it changes the conversation between developers and operations. A practical episode for anyone drowning in dashboards.

    #DevOps #Observability #ServiceLevelObjectives #SLO #SLI #ErrorBudget #SiteReliabilityEngineering #SRE #IncidentResponse #DevOpsDaily #FexingoBusiness #BusinessPodcast #Technology #Monitoring #Alerting #Ecommerce #Reliability #LucasAndLuna

    Keep every episode free: buymeacoffee.com/fexingo

    10 min
  • Why Your Deployment Rollback Is Probably Broken

    Lucas and Luna dig into a failure mode that haunts every DevOps team: the deployment rollback that doesn't actually work when you need it. They break down the classic 'rollback is just redeploying the last good image' myth, using a real incident from a mid-size fintech company that lost 15 minutes of transaction data because their rollback restored code but not database state. Lucas explains the difference between stateless and stateful rollbacks, why Kubernetes Helm hooks can fool you, and how a team at a payments startup fixed their process by adding pre-rollback smoke tests. By the end, you'll know why you should test your rollback script on the first of every month, not just after an outage. No vague best practices, just a concrete mistake and a fix you can steal.

    #DevOpsDaily #CI/CD #Kubernetes #Rollback #Deployment #IncidentResponse #DatabaseMigrations #Helm #Fintech #StatefulRollback #SmokeTests #Pipeline #ProductionIncident #SoftwareOperations #Technology #FexingoBusiness #BusinessPodcast #DevOpsPodcast

    Keep every episode free: buymeacoffee.com/fexingo

    11 min
  • Kubernetes Costs Are Eating Your Cloud Budget

    Lucas and Luna dig into the hidden cost of Kubernetes. Most teams track CPU and memory but miss data egress, control plane charges, and orphaned volumes. Lucas cites a real example: a mid-stage SaaS startup was spending $12,000 a month on cross-zone traffic they didn't know they were generating. They walk through three specific ways to audit your cluster costs — namespace-level tagging, rightsizing requests and limits, and using Kubecost or OpenCost for allocation visibility. Luna pushes back on the trade-offs: if you optimize too hard for cost, do you sacrifice reliability? They land on the idea that cost awareness is a team discipline, not a tool install.

    #Kubernetes #CloudCosts #DevOps #KubernetesCostOptimization #FinOps #CloudComputing #Kubecost #OpenCost #ContainerOrchestration #K8s #CostManagement #Infrastructure #TechPodcast #SoftwareEngineering #CloudNative #FexingoBusiness #BusinessPodcast #DevOpsDaily

    Keep every episode free: buymeacoffee.com/fexingo

    10 min
  • The Pipeline That Broke at Two in the Morning

    In the premiere episode of DevOps Daily, Lucas and Luna open with a story every engineer knows: a deploy at 2 AM breaks production because a database migration ran before the schema change was applied. That human error, repeated in companies big and small, is exactly what modern CI/CD pipelines are designed to prevent — and why a well-built pipeline is more than just automation. Lucas walks through the anatomy of a deploy pipeline, how Kubernetes changed the game for rollbacks, and why the real bottleneck isn't the tooling — it's the testing strategy. Luna pushes back on the idea that 'just add more stages' fixes everything, pointing to a 2024 incident where a 47-stage pipeline still shipped a null pointer exception into production. Together they lay out what this show is about: not theory, but the specific decisions — branching models, test parallelization, canary releases, observability hooks — that separate a smooth Monday morning from a weekend on-call.

    #DevOps #CI/CD #Kubernetes #SoftwareEngineering #Deployment #Pipeline #ProductionIncident #Automation #Testing #CanaryRelease #Rollback #Observability #Technology #FexingoBusiness #BusinessPodcast #DevOpsDaily #LucasAndLuna #ModernOperations

    Keep every episode free: buymeacoffee.com/fexingo

    7 min

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

From the publisher's feed

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.