The Node (and more) Banter

Platformatic

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.

  1. 6D AGO

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

    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. Node.js FFI changes the migration conversation for every enterprise sitting on legacy native code. If it runs DOOM, it runs your C library. No excuses.

    36 min

  2. MAY 6

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

    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. This episode, along with the white paper, argues that smarter scaling is now essential, not just a bonus.

    37 min

  3. APR 29

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

    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.

    31 min

  4. APR 22

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

    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? ✅ The "ask-to-get" model. How developers can request access to URLs or disk policies without blowing up the enterprise approval process ✅ Honest takes on sandbox security, adversarial escapes, and what "good enough" actually means The takeaway? Agents aren't a new category of software. They're stateful Node.js processes, and the hard part was never the AI model, it was everything around it: the state management, the routing, the isolation, and the governance. If you're thinking seriously about deploying agents inside your company's infrastructure, this episode gives you the full picture of what that actually requires.

    34 min

  5. APR 15

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

    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.

    51 min

  6. APR 8

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

    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.

    43 min

  7. APR 1

    Bringing @workflow to your Kubernetes

    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.

    30 min

  8. MAR 25

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

    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.

    31 min
See All (59)

About

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.

Information

You Might Also Like