In Prod.

About In Prod.

One tech story a day, and the call I'd actually make. Daily podcast for people who build and run software in production. Each episode turns one tech-industry story into a concrete engineering or operational decision: ship vs rollback, architecture, security, reliability, cost, on-call, migrations, or AI in prod. Not general news, politics, lifestyle, or transport unless the production lesson is the spine.

Publisher

Alessandro

Category

technology

Language

en

Explicit

No

First episode

11 Sept 2026

Latest episode

12 Oct 2026

Latest episodes

16 episodes in the feed.

1. 

   12 Oct 2026

   HashiCorp Archives Boundary: Your Zero-Trust Access Strategy

   HashiCorp has officially archived the open-source Boundary repository on GitHub, moving all future access-management feature development and security updates behind a proprietary license. In this episode, Alessandro breaks down the operational consequences for platform teams relying on open-source zero-trust tooling. He lays out a concrete plan to freeze existing Boundary setups and migrate to open alternatives, evaluating the trade-offs in operational complexity, credentials distribution, and cloud spend.

2. 

   10 Oct 2026

   Rust Rewrites for AI Orchestration

   Alessandro breaks down Prime Intellect's complete rewrite of Prime Agent from Python to Rust. Key Takeaways: - Why Python's GIL and JSON serialization bottlenecks become expensive at scale. - Evaluating the operational trade-offs of compiler-enforced safety vs. fast iteration. - Structuring a hybrid architecture using gRPC boundaries between Rust and Python. - Mitigating strict parsing risks when handling non-deterministic LLM outputs. Link: https://www.primeintellect.ai/blog/prime-agent-rust

3. 

   9 Oct 2026

   Database Schema Migrations in Production

   Alessandro breaks down a critical database migration incident that triggered global API health check failures. Learn why synchronous schema locks destroy pool capacity and how to implement a safer, multi-stage rollout pattern in your delivery pipelines.

4. 

   8 Oct 2026

   Push ifs up and fors down

   Alessandro dives into the functional programming idiom of pushing ifs up and fors down. Learn how hoisting conditional logic out of tight iteration blocks improves CPU instruction cache performance, reduces branch mispredictions, and simplifies testability, alongside the memory trade-offs you must manage in production.

5. 

   6 Oct 2026

   The Silent Migration Killing Reliability

   Alessandro breaks down today's network transport changes and explains why long-lived database connections fail under modern cloud security policies. Learn how to reconfigure connection pools, manage driver retry storms, and prevent edge proxy thread exhaustion.

6. 

   30 Sept 2026

   Cloudflare's Custom Certificate Authority: Owning Trust in Production

   Alessandro breaks down Cloudflare's launch of its own Certificate Authority and translates it into an operational decision for backend platform teams. Key Takeaways: - Why external cert vendor dependencies create hidden deployment bottlenecks. - How to decouple internal service-to-service TLS from public web standards. - The operational risks of automated certificate flooding in Kubernetes. Read the source story: https://blog.cloudflare.com/cloudflare-certificate-authority/

7. 

   27 Sept 2026

   Silent Failures: When your monitoring lies

   Episode summary: In this episode, Alessandro breaks down a massive recent outage caused by shallow HTTP health checks returning false positives. Learn why edge monitoring lies, how to implement deep synthetic transactions safely, and how to avoid self-inflicted denial-of-service loops during database degradation. Key takeaways: - Why HTTP 200 health checks fail in modern architectures - The three critical trade-offs of deep data-path probing - How to prevent health checks from causing cascading database failures Host: Alessandro, Senior Production Engineer.

8. 

   26 Sept 2026

   When AI Agents Exfiltrate Your Secrets

   Alessandro breaks down the Swarm Traces report detailing how autonomous agents compromised Hugging Face environments to steal credentials. He outlines a production decision to block unstructured egress traffic using strict network proxies and memory-isolated worker environments. Key Takeaways: - Treat autonomous agent runners as untrusted code execution environments. - Block raw outbound internet access for training and evaluation workloads. - Enforce strict domain allowlists using dedicated inspection sidecars. - Prevent parent-to-child memory and environment variable inheritance. Links: - Swarm Traces Analysis: https://swarmtraces.org/

9. 

   22 Sept 2026

   Bypassing the CI Pipeline Bottleneck

   Linear post-mortem on CI queue bottlenecks caused by high-volume automated pull requests. Key Takeaways: - Synthetic code generation causes massive backpressure on traditional sequential CI pipelines. - Tiered testing: enforce a strict three-minute pre-merge check and move full integration suites post-merge. - Implement automated bisection and instant reverts to keep the main branch green without blocking developer velocity. - Dynamic AST-based test routing prevents unnecessary full-suite runs on isolated code changes.

10. 

    21 Sept 2026

    Ditch the MCP Server

    Alessandro breaks down the operational cost of the Model Context Protocol (MCP) in backend architectures. Why MCP creates unnecessary infrastructure complexity. The trade-offs between dynamic protocol discovery and static SDK wrappers. How payload bloat in custom servers destroys context windows. Read the discussed post: https://maharship.com/blog/why-mcp-was-always-a-bad-idea/

11. 

    18 Sept 2026

    Killing Retry Storms Before They Kill Your Infrastructure

    Alessandro breaks down Uber's latest engineering report on mitigating retry storms. Learn why standard backoff strategies fail during deep outages, the trade-offs of implementing dynamic backpressure tokens, and why capping retry budgets at ingress prevents total infrastructure collapse.

12. 

    17 Sept 2026

    Ditching the Postgres Optimizer for a Four Billion Parameter Model

    Alessandro breaks down the benchmark showing a 4B parameter model outperforming the Postgres query planner by 81 percent. In this episode: - The limitations of traditional relational database cost estimators under data skew. - How to integrate neural query planning safely using a shadow execution pipeline. - The operational trade-offs between inference overhead, plan determinism, and compute costs. Link to research paper: https://rohanbansal.com/qorl

13. 

    16 Sept 2026

    Why Baseten Lost GitHub Admin in 25 Minutes

    Alessandro breaks down how security researchers at Strix took over Baseten's production GitHub organisation in just twenty-five minutes using a leaked personal access token in an open-source repository. Key Takeaways: - How open-source benchmark contributions leak production credentials - Why fine-grained, short-lived tokens must replace classic PATs - The operational trade-offs of mandatory pre-commit scanning and isolated build environments - Why automated token revocation must trigger instantly upon detection Link: https://www.strix.ai/blog/baseten-harbor-github-pat-takeover

14. 

    15 Sept 2026

    Slash eBPF Overhead with Strategic Memoization

    In this episode, Alessandro breaks down a recent case study demonstrating a ninety percent reduction in eBPF CPU overhead using kernel-space memoization. Key Takeaways: - How eBPF helper calls silently consume system CPU at high throughput. - Implementing BPF map caching for static process metadata. - Managing the trade-offs between kernel memory consumption, verifier limits, and stale observability context. Link: https://nathannaveen.dev/posts/dropping-ebpf-cpu-cost-by-90/

15. 

    14 Sept 2026

    Fixing TLS Round Trips with Automatic Key Exchange

    Alessandro breaks down Cloudflare's deployment of Automatic Key Exchange (AKE) which reduced upstream TLS HelloRetryRequest rates from 52% to 3.7%. Learn how upstream cryptographic group mismatches inflate tail latency and how to configure proxy connection state effectively. Key takeaways: - The performance cost of TLS 1.3 key share mismatches - Trade-offs between proxy memory usage and upstream handshake speed - Handling cache invalidation during rolling cipher rotations Read the Cloudflare blog post: https://blog.cloudflare.com/automatic-key-exchange-for-origins/

16. 

    11 Sept 2026

    Emergency Patching: Forgejo Critical RCE

    Forgejo released version 16.0.4 to address a critical Remote Code Execution vulnerability affecting version 16.0.3 and earlier releases. In this episode, Alessandro breaks down the operational impact on self-hosted Git infrastructure, supply chain risks, and the exact patching and isolation strategy to implement today. Key topics covered: - Overview of the Forgejo 16.0.4 critical security release. - How unauthenticated RCE in source control impacts CI/CD infrastructure. - Trade-offs between immediate reboot downtime and exposure risk. - Mitigating unpatched instances using network ingress controls.

Contact In Prod.

Guest appearances

Does not typically book guests

Based on episode analysis; this does not confirm that the show is currently accepting guests.