All Episodes

No, we should not distribute TypeScript files

NodeConf EU Came Back. Nobody Mentioned AI.

Do You Still Read Code Written by AI?

The Sandbox Was Fine. JavaScript Wasn't

State Without a Landlord

Imagine a world where npm...

The HTTP/2 Bugs Hiding in Plain Sight

Will AI Kill the Framework?

Every Week the Same Spike. Every Week Your Autoscaler Is Surprised.

Who Gets to Decide When You Can Use AI?

Should You Block the Event Loop?

Nitro Builds the Server. Who Runs the Fleet?

Your Bug Fix Will Never Reach the Runs That Need It

Are Your AI Agents Really Production Ready?

Is AI Saving Open Source Or Just Using It?

Your Node.js Gateway It's Doing Twice the Work

How Do You Build Skew Protection? Let's unpack it

Why Shipping Fast Breaks Your Users (and How to Stop It)

Node.js Left 26% Performance on the Table for 10 Years

Performance/Memory tradeoff. Can we have both instead?

How Do We Scale Rate Limiting in Node.js?

Requests, Limits, and the Throttling Trap: K8s Resources for Node.js

Should We Rewrite Node.js in Rust?

We Ran DOOM in a Node.js Terminal. Now There's No Excuse for Your Legacy Native Code (with Paolo Insogna)

Predictive Autoscaling for Node.js: Why Reactive Systems Are Costing You More Than You Think

Sandboxing Ai Agents in Kubernetes: Why Regina Uses eBPF and Not a VM

Ai Agents, Kubernetes, and the Sandbox That Now Runs Inside Your Cluster

TanStack Start, AI, and Performance: Rethinking Full-Stack Architecture (with Tanner Linsley)

Skills, Agents & the Setup That Actually Works for AI-assisted JS Development

Bringing @workflow to your Kubernetes

Node.js VFS: Unlocking Dynamic Code, Testing, and Multi-Tenancy

Why Node.js Is the Critical Enabler for AI Applications

Kubernetes Finally Gets Vercel-Style Deployment Safety

From Black Box to Transparent: Building Auditable AI Apps

Double the Density. Half the Memory (with James Snell)

Caching in the Enterprise: Why Most Companies Aren’t Doing It

HTTP, Queues, Actors: Watt Keeps Node.js Running Smoothly

Scaling Node.js with the Right Signals: ELU, Kafka, and Kubernetes

GraphQL in the Enterprise: Debunking the Myths About Its 'Niche' Problem

When Recursion Crashes Your App: The Async Hooks DoS Nobody Expected

The JAMstack Is Dead. Long Live the Runtime!

Inside the React RCE: What the Flight Vulnerability Really Reveals

The Node.js (R)evolution started - AWS just made it official

93% Faster Next.js: What Our Benchmarks Really Reveal About Next.js at Scale

When Rendering Blocks: How Next.js Internals Stress the Node.js Event Loop

Next.js at Scale: The Hidden Challenges of Enterprise Adoption

React's New Era: Compiler Magic, Native Architecture, and Foundation Shift

Workflow Wars: From Kafka Chaos to Durable Dreams

The Node (& More) Banter: Special — The Best of Node.js Conversations

Seeing the Full Picture: Heap Profiling for Node.js Apps

Node.js Loves Python: Running ASGI Apps Inside Your Node.js Services

Inside the Latest npm Attack (with Feross Aboukhadijeh)

The Myths (and Costs) of Running Node.js on Kubernetes

From Reactive to Predictive: Smarter Node.js Operations at Scale

Type-Safe API Clients: The Future of Integration

The Cost of Not Updating Node.js (with Erick Wendel)

Reading the Fire: Flamegraphs and the Hunt for Node.js Bottlenecks

Stop Reinventing the Wheel: Mastering HTTP Caching

The danger of SetImmediate

The Hidden Cost of Async Context in Node.js (with Bryan English)

Stateful by Design: Rethinking Team AI Workflows with AI-Warp

MCP: The New Interface of the AI Stack (with Alex Olivier)

The Illusion of Standardization: Templating Gone Wild

The Hidden Cost of the Sidecar Pattern (with Roberto Bianchi)

Runtime Composition: The Missing Layer

The Platform Trap

Make vs Build: The Architecture Fork

Your Stack Is Charging You

The BFF Pattern: Glue or Liability?

Node loves PHP: Reuniting Web’s Power Duo for the Microservices Era

From Sensors to Sentience: Making APIs AI-Ready in the Age of Smart Devices

Command Query Responsibility Segregation (CQRS) and Event Sourcing

Microservices and Kafka

A deep dive into the OpenAPI Specification

Distributed Systems Series: Authentication and Authorization Part 2

Distributed Systems Series: Authentication and Authorization Part 1

A Deep Dive into Fastify with Tomas Della Vedova

How do I maintain services in a distributed system?

Scaling Node.js: Microservices & Kubernetes

Deploying Node.js on AWS EKS....but make it scalable!

Unpacking Config & Env Variables in Node.js

A guide to building stateful distributed systems