The Node (and more) Banter – Details, episodes & analysis

Podcast details

Technical and general information from the podcast's RSS feed.

The Node (and more) Banter

Platformatic

Technology

Frequency: 1 episode/6d. Total Eps: 60

The Node (and more) Banter is your weekly dose of unfiltered, unscripted conversations between Luca Maraschi and Matteo Collina. We explore the edge cases, the anti-patterns, and the things no one puts in the docs. From distributed architecture to platform pitfalls and how enterprises tackle modern development—nothing’s off-limits. It’s not just Node.js®—it’s everything around it, wrapped in sharp banter, war stories, and real-world insight. The sky’s the limit.

Read moreCollapse

Site

RSS

Apple

Data updated on 14/07/2026

Recent rankings

Latest chart positions across Apple Podcasts and Spotify rankings.

Apple Podcasts

Spotify

No recent rankings available

Shared links between episodes and podcasts

Links found in episode descriptions and other podcasts that share them.

See all

No links shared by this podcast

RSS feed quality and score

Technical evaluation of the podcast's RSS feed quality and structure.

See all

RSS feed quality

To improve

Score global : 58%

Publication history

Monthly episode publishing history over the past years.

Year

Latest published episodes

Recent episodes with titles, durations, and descriptions.

See all

Should We Rewrite Node.js in Rust?

Season 2 · Episode 19

Wednesday, May 20, 2026 • Duration 29:21

Bun made the switch. Zig is out, Rust is in, and AI handled most of the work, with 98% of the test suite passing. The question is no longer hypothetical; it's real now. If an AI can port an entire runtime, why are so many enterprise teams still stuck on a Node 12 codebase they're afraid to update?

In this episode of The Node (and more) Banter, Luca Maraschi and Matteo Collina talk about the Bun Zig-to-Rust port, including the memory leaks that led to the change, the rumors around it, and what it means that AI made it happen. They also look at the bigger picture: meta-cloud platforms losing their advantage, Node.js downloads passing 680 million a month thanks to AI tools, and why major AI companies still don't have a seat on the Node.js TSC, even though they build billions of dollars of products on it.

In this episode, we cover:

✅ Why Bun is moving from Zig to Rust, and why memory safety matters more than the drama

✅ How AI managed to port a full runtime with 98% of tests passing, and what made this possible

✅ The key to AI-powered migrations: integration tests that focus on results, not how things are built

✅ Can enterprise teams do the same, and what does upgrading from Node 12 to Node 24 with AI really look like?

The takeaway?

The real breakthrough wasn't the model, but the test suite. Without integration tests, there is no migration, whether you use AI or not. That's the lesson hidden in the Bun story, and it's one most teams will miss while debating Rust versus Zig.

Read moreCollapse

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

Season 2 · Episode 18

Wednesday, May 13, 2026 • Duration 36:21

What started as a joke at the Node Collaborator Summit turned into the most compelling argument yet for why enterprises have no excuse left to avoid modernizing their native code.

In this episode of The Node (and more) Banter, Luca and Matteo are joined by Paolo, Principal Software Engineer at Platformatic, who built "Project Destino" — because in Italian, destino means doom, and yes, that's exactly how we name things.

That comment in London turned into a fully working DOOM port running at 35fps inside your terminal, with sound, powered entirely by Node.js FFI, OpenTUI, and a C library called DOOM Generic.

In this episode, we cover:

✅ How Node.js's native FFI module lets you load and run any C library. No native addons, no compilation headaches

✅ Why the game loop lives in JavaScript (via setInterval) while the engine ticks happen across the FFI boundary

✅ The FFI performance story: from 150 nanoseconds per call down to 15, close to the theoretical minimum

✅ Node.js Single Executable Applications (SEA): ship everything — game, sound, native libraries — as one binary

✅ The enterprise reality: if FFI can run DOOM, it can run your legacy DLLs — and there's no migration excuse left

✅ What's next: llama.cpp via FFI, NVIDIA GPU experiments — and possibly Prince of Persia

The takeaway?

We didn't port DOOM because it made sense. We did it because the technology made it possible — and that's exactly the point.

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

Season 2 · Episode 17

Wednesday, May 6, 2026 • Duration 36:35

Many teams believe autoscaling is simple: set a CPU threshold and let Kubernetes handle it. But if you get a three-minute traffic spike and your pods need two minutes to start, users feel the lag, the spike ends, and your new pods show up too late. What if your infrastructure could predict traffic instead of just reacting?

In this episode, Luca Maraschi and Matteo Collina challenge the usual autoscaling approach—HPA, KEDA, ECS, and more. They explain the predictive scaling algorithm Platformatic created for their Intelligent Command Center (ICC). Matteo explains why scaling is a nonlinear problem that the industry keeps trying to solve with linear solutions, and how thinking of a distributed system like a neural network can change how scaling decisions are made.

In this episode, we cover:

✅ Why reactive autoscalers always use outdated data by design, and why this is a core flaw, not just a configuration issue

✅ The real cost of pod boot time that often gets ignored: spawn time, warmup, and traffic rebalancing

✅ Why CPU and memory are not the right metrics for Node.js, and what you should measure instead

✅ How Platformatic's algorithm checks event loop utilization from outside the thread, with no interference and no extra overhead

✅ The benchmark results: 99.47% success rate compared to 95% with KEDA and 90% with HPA, with P99 latency ten times better

✅ The 46-page white paper they published, and why they believe it's time to stop scaling out of fear

The takeaways?

Over-provisioning is not a safety net; it shows the model is broken. If your system cannot predict load, you will always have to choose between wasting money and getting worse performance.

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

Season 2 · Episode 16

Wednesday, April 29, 2026 • Duration 31:02

Running AI agents in production isn't just about picking the right LLM. It's about the infrastructure decisions that make them safe, fast, and deployable at scale. Choosing between micro VMs, gVisor, Firecracker, or eBPF sounds like a systems engineering rabbit hole, until you realize the wrong choice can mean seconds of startup latency, infrastructure bloat, or an isolation model that doesn't match your actual threat surface.

In this episode of The Node (& More) Banter, Luca Maraschi and Matteo Collina go deep on the architecture behind Regina, Platformatic's AI agent sandbox, and explain exactly why they chose eBPF over traditional VM-based isolation. We unpack the two fundamental agent sandbox patterns, the trade-offs between logical and physical isolation, and why Node.js turned out to be a surprisingly perfect fit for systems-level eBPF work.

We'll explore:

✅ eBPF vs. micro VMs: startup latency, infrastructure complexity, and where the real boundary sits

✅ Process-level vs. container-level isolation and why granularity changes everything for agents

✅ The snowflake problem: managing stateful agents across Kubernetes pod restarts

✅ How syscall and network policies are enforced at runtime, per agent process

✅ Why Node.js is a natural fit for eBPF and why they built their own stack instead of using OpenCilium

The big picture?

Infrastructure shapes safety. If you're building or deploying AI agents on Kubernetes, this episode gives you the mental model for why isolation at the process level, not the container level, matters and why Node.js can hold its own as a systems language when the architecture is right.

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

Season 2 · Episode 15

Wednesday, April 22, 2026 • Duration 34:04

Most teams building AI agents treat Kubernetes like it's optional. They spin up a Mac Mini, run their agent locally, and call it a day, until someone asks how to scale it, govern it, or deploy it across the enterprise. That's when the architecture falls apart. The question is: what does it actually take to run agents in production, at scale, inside the infrastructure you already have?

In this episode of The Node (and more) Banter, Matteo Collina and Luca Maraschi do a full debrief on Platformatic's launch week, unpacking what they shipped, why they built it, and the hard distributed systems problems they had to solve along the way. From Regina, the open-source agent runtime built on top of Watt, to a Kubernetes-native sandbox powered by eBPF, this is the behind-the-scenes breakdown of what it takes to bring agentic infrastructure to the enterprise.

In this episode, we cover:

✅ What Platformatic launched. Regina, the agent sandbox, and the enterprise Kubernetes layer

✅ Why agents are fundamentally stateful and why that breaks every assumption Kubernetes was built on

✅ How Regina lets you define agents as a combination of Markdown and TypeScript, with state stored in SQLite and communication between agents baked in

✅ The coordinator model: how Platformatic routes agent traffic inside Kubernetes without relying on a standard load balancer

✅ Why we rejected the E2B remote VM model, and built a sandbox using eBPF directly inside the cluster instead

✅ The governance problem nobody is talking about: who owns the agent, and how do you separate API access concerns from agent execution concerns?

✅ . How developers can request access to URLs or disk policies without blowing up the enterprise approval process

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

Season 2 · Episode 14

Wednesday, April 15, 2026 • Duration 50:33

Full-stack development is moving fast. TanStack Start is changing how we handle data fetching, routing, and server-client boundaries. AI tools like Claude are speeding up how we build and test these systems. But when it’s time for production, one question matters: how do you scale CPU-bound workloads like SSR without losing performance?

Luca Maraschi and Matteo Collina sit down with Tanner Linsley, creator of TanStack, to dig into the core principles behind the TanStack ecosystem and what happens when those ideas hit real infrastructure. We share recent benchmarks of TanStack Start running on Watt under heavy load, showing exactly how architecture choices affect throughput, latency, and reliability.

In this episode, we cover:

✅ The core principles behind TanStack and why they resonate with modern developer workflows

✅ What happens when TanStack Start hits production workloads, including SSR and CPU-bound bottlenecks

✅ Insights from benchmarking at 1000 req/sec on Kubernetes and what they reveal about real-world performance

✅ Why kernel-level load balancing and multi-worker architectures improve tail latency without adding overhead

If you’re building or leading teams on modern full-stack apps, this episode is for you. We break down how framework design, AI tools, and runtime architecture combine to power the next wave of scalable web systems.

Read moreCollapse

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

Season 2 · Episode 12

Wednesday, April 8, 2026 • Duration 43:01

Most developers let their AI assistant guess how to write Node.js. No context, no constraints, no history, just vibes and generic output. The result is code that ignores the event loop, skips proper error handling, and looks nothing like how senior engineers actually build. The question is: can you actually teach your AI to code like you?

In this episode of The Node (and more) Banter, Luca Maraschi and Matteo Collina dive into the emerging AI toolchain for Node.js development, from Agent Skills to coding agents like OpenClaw and Pi. Matteo shares his own personal skills repository (mcollina/skills), a collection of battle-tested Node.js, Fastify, and TypeScript best practices that any AI coding assistant can load and apply out of the box.

In this episode, we cover:

✅ What Agent Skills are and why the open standard changes how AI-assisted development works

✅ Why Matteo got frustrated with AI slop and built his own skills repo — and what's inside it

✅ How to install and use mcollina/skills with Claude Code, GitHub Copilot, OpenAI Codex, and more

✅ What OpenClaw and Pi are, and how they fit into the Node.js AI toolchain

✅ The practical question: what should a JavaScript developer actually install today to code with AI effectively?

✅ The difference between prompting from scratch every time vs. encoding your expertise once and reusing it everywhere

The takeaway? AI-assisted development isn't just about which model you use, it's about the context you give it. Skills are how you stop training your AI from zero on every project and start shipping faster, with fewer corrections. If you're building with Node.js and you're not using skills yet, this episode will change how you set up your workflow.

Bringing @workflow to your Kubernetes

Season 1 · Episode 12

Wednesday, April 1, 2026 • Duration 29:50

Workflows look easy… until they corrupt your data.

Durable workflows in Node.js promise retries, persistence, and long-running execution. On platforms like Vercel, everything just works. But the moment you move to Kubernetes, a hidden problem appears: version mismatch. A small code change can replay the wrong steps, mix results, and silently break your system.

The question: how do you run durable workflows safely in production?

Luca Maraschi and Matteo Collina dive into workflow orchestration in Node.js and the real challenges behind deterministic execution. From Workflow DevKit to Platformatic World, they break down how version-safe workflows work on Kubernetes, ensuring every run is pinned to the exact code version that created it, even across deployments, retries, and long-running jobs.

In this episode, we cover:

✅ Why durable workflows break on Kubernetes and not on Vercel

✅ How deterministic replay works and why it can corrupt data

✅ The hidden problem of versioning in long-running workflows

✅ How Platformatic World enables version-safe orchestration

✅ Why queue routing is critical for workflow correctness

✅ What zero-config workflows look like in real production systems

If you're building with Node.js, Kubernetes, or event-driven architectures, this episode is for you. Durable workflows are powerful, but without version safety, they’re a risk. This is what it actually takes to run them in production.

Read moreCollapse

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

Season 2 · Episode 11

Wednesday, March 25, 2026 • Duration 30:32

Node.js delivers high-performance I/O, moving data fast between network and disk. But today’s cloud-native, serverless, and AI-driven workloads hit a wall: the filesystem isn’t virtual. That means you can’t import in-memory modules, sandbox tenants, or bundle assets into a single executable without bloating binaries. The question: how do we unlock these capabilities?

Luca Maraschi and Matteo Collina dive into Node.js Virtual File System (VFS): from @platformatic/vfs in userland to the upcoming node:vfs in core. VFS enables in-memory testing, sandboxed multi-tenancy, AI agents, and code-generation pipelines, features that standard fs simply can’t deliver.

In this episode, we cover:

✅ The limitations developers face without a virtual filesystem and why traditional workarounds fall short

✅ How VFS plugs into Node.js fs and module loader to enable dynamic modules for AI and runtime code

✅ VFS architecture: providers, mounts, overlays, and seamless import/require integration

✅ Real-world use cases: single executables, isolated tests, AI agents, plugins, and codegen workflows

✅ Why VFS belongs in core Node.js, and what sets core apart from userland.

If you need flexibility, isolation, or advanced runtime power in Node.js, this is for you. Virtualizing the filesystem is a game-changer for developers, enterprise teams, and AI platforms.

Read moreCollapse

Why Node.js Is the Critical Enabler for AI Applications

Season 2 · Episode 10

Wednesday, March 18, 2026 • Duration 38:45

AI applications are shifting from experiments toward real-world systems. As teams move to production, common challenges come up, such as managing low latency, handling concurrent requests, and integrating with different data sources and APIs. But beyond the models and prompts, there’s an important infrastructure question: Which runtime can handle AI workloads at scale and still be easy for developers to use?

In this episode of “The Node (and more) Banter,” Luca Maraschi and Matteo Collina talk about why Node.js has become a key instrument for modern AI applications. Whether it’s managing LLM APIs, streaming responses, or building real-time agent systems and scalable AI backends, Node.js is at the heart of many production AI platforms.

We’ll discuss why Node.js’s event-driven design works so well for AI workloads, how developer productivity speeds up AI development, and what enterprise teams should think about when building reliable AI services.

Here’s what we’ll cover:

✅ Why most AI applications are about orchestration, not simply building models

✅ How Node.js manages streaming, concurrency, and real-time AI responses

✅ The role JavaScript plays in connecting models, APIs, and user interfaces

✅ Why developer speed matters in the fast-changing world of AI

✅ What enterprise teams need to think about when running AI workloads in production

If you’re building or leading teams working on AI-powered products, this conversation will show why Node.js is becoming a key part of today’s AI stack.

The Node (and more) Banter – Details, episodes & analysis

Podcast details

Recent rankings

Apple Podcasts

Spotify

Shared links between episodes and podcasts

RSS feed quality and score

Publication history

Latest published episodes

Related Shows Based on Content Similarities

Apple Podcasts

Spotify

Related Shows Based on Content Similarities

The Node (and more) Banter – Details, episodes & analysis

Podcast details

Recent rankings

Apple Podcasts

Spotify

Shared links between episodes and podcasts

RSS feed quality and score

Publication history

Latest published episodes

Similar podcasts and content

Related Shows Based on Content Similarities

Apple Podcasts

Spotify

Related Shows Based on Content Similarities