PODCAST · technology
The Node (and more) Banter
by 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.
Episodes
-
No, we should not distribute TypeScript files
Jarred Sumner’s argument is that for JavaScript and TypeScript to stay relevant in an AI world, where moving a codebase between languages is suddenly cheap, they have to get as fast as Rust or Go. Luca and Matteo work through what that costs. AssemblyScript already solved it by not being...
-
NodeConf EU Came Back. Nobody Mentioned AI.
NodeConf EU came back after a year off, new team, new country, and one deliberate decision: nothing about AI on the schedule. What filled it instead ranged from Node.js core internals, such as the new Foreign Function Interface or Garbage Collector internals, to an “instruction manual” for the EU...
-
Do You Still Read Code Written by AI?
Here is the claim. For an experienced programmer, reading AI-generated code is not diligence, it is a bottleneck. Complex code takes longer to read properly than to write from scratch, so the review you think you are doing is not happening. Luca and Matteo pick that up and pull on it until...
-
The Sandbox Was Fine. JavaScript Wasn't
On September 15, Accomplish AI revealed Heapjack, a method that lets someone run any command from OpenAI Codex Desktop, even in its strictest read-only mode, without asking for approval. If you clone a repo and ask a question, the repo’s author could take control of your machine. The issue was...
-
State Without a Landlord
Workflows function as an append-only log, and so does HyperCore. Luca explored that line of inquiry and, as a result, produced a 50-page paper in which agent state is replicated peer-to-peer, without the need for a central repository or a cloud provider in the middle, and all of it runs entirely...
-
Imagine a world where npm...
What if you could execute a package without ever unzipping it? What if npm had no central server, just a peer-to-peer mesh with cryptographic integrity baked in? No slides, no answers, no agenda. Just Luca Maraschi and Matteo Collina following the current wave of NPM, and GitHub outages to their...
-
The HTTP/2 Bugs Hiding in Plain Sight
Most develpors skip release notes. You update a library, the tests pass, you deploy, and everything seems fine. Later, someone spots that 0.025% of requests are failing; not enough to set off alarms, but too steady to ignore. This is what happens with the HTTP/2 upgrade you might not have…
more -
Will AI Kill the Framework?
There's a growing belief that AI-generated code is so fast and cheap that foundational, general-purpose tools are obsolete. The argument goes: why optimize for everyone when you can generate code tailored to each workload? Some claim frameworks are outdated and the future is ad-hoc and…
more -
Every Week the Same Spike. Every Week Your Autoscaler Is Surprised.
Every Friday evening, your traffic goes up. Each weekday morning, your app becomes active again. Overnight, things slow down. Your autoscaler has seen this pattern many times, but tomorrow it will act like it’s new. It waits for a metric to cross a threshold, then starts adding capacity, which...
-
Who Gets to Decide When You Can Use AI?
Matteo works on cybersecurity for Node.js every day. AI has become essential for managing the flood of new vulnerabilities. Still, Fable blocks anything that interacts with a pointer, Anthropic's frontier models are off-limits for security research, and the US government can change the rules at…
more -
Should You Block the Event Loop?
Every Node.js developer learns the same rule on day one: never block the event loop. Async is good, sync is bad, and the libuv thread pool is your friend. Then a real customer brought Luca and Matteo a compression problem that turned all of that upside down. Turns out, the rule is only half the...
-
Nitro Builds the Server. Who Runs the Fleet?
Nitro gives you a clean, portable server. Whether you use it on its own or with Vite, you get consistent builds, familiar routing, and a smooth development workflow. But Nitro doesn’t explain what to do when you have several instances and a cron job, or when you need a gateway, metrics, and…
more -
Your Bug Fix Will Never Reach the Runs That Need It
You spot a critical bug in production, fix it, deploy, and feel relieved. But then you notice the workflows that need the fix most, like 30-day subscription cycles, compliance timers paused for months, or approvals waiting on a signature, are still stuck on the old version. They never get the…
more -
Are Your AI Agents Really Production Ready?
Eve is a well-designed open-source agent framework. It offers a clean programming model, filesystem-based instructions and tools, and durable sessions built on the Workflow SDK. However, running Eve in a real enterprise Kubernetes environment needs extra infrastructure that isn't included by...
-
Is AI Saving Open Source Or Just Using It?
People keep saying that AI helps developers get more done. But few are asking who pays for the computing power, tokens, and time needed to keep the open-source projects behind AI running. Node.js maintainers often use their own servers, patch together free subscriptions, and struggle to get…
more -
Your Node.js Gateway It's Doing Twice the Work
You launch a new product. Thousands of users click the same link at the same time. The cache is cold, and your Node.js app starts generating the exact same response hundreds of times simultaneously, burning CPU, hammering your database, and slowing down for everyone. This is the thundering herd...
-
How Do You Build Skew Protection? Let's unpack it
"Zero downtime" doesn’t mean there’s no risk. When you release new code, some users still have the old version open in their browser, using outdated JS bundles and React state, without realizing anything has changed. Teams usually find out when a checkout fails or a form resets in the middle of a...
-
Why Shipping Fast Breaks Your Users (and How to Stop It)
You deploy several times a day. Your team moves quickly, and your lead time is short. But each deployment can quietly disrupt users already on your site. There are no big warnings, just someone clicking around, suddenly running into errors because the app in their browser and your updated server...
-
Node.js Left 26% Performance on the Table for 10 Years
A default set in May 2015 just got its first change. One constant. One number. And it was silently costing Node.js up to 26% throughput on some of the most common workloads in the ecosystem: file reads, HTTP parsing, stream chunking. Nobody broke it. Nobody was ignoring it. It was just stuck in a...
-
Performance/Memory tradeoff. Can we have both instead?
Memory and performance often compete with each other. Most developers only notice this tradeoff when something goes wrong, not during the initial design. At that point, the key decisions are already set. In this episode of The Node (and more) Banter, Luca Maraschi and Matteo Collina talk about…
more -
How Do We Scale Rate Limiting in Node.js?
Your Node.js service has rate limiting. You tested it, it worked, you shipped it. But your limit lives in the memory of a single process, and the moment you run more than one instance behind a load balancer, every replica enforces its own private budget. Ten instances means ten times the traffic...
-
Requests, Limits, and the Throttling Trap: K8s Resources for Node.js
You set a CPU limit on your pod, the node has plenty of capacity to spare, and yet your Node.js service is throttled to a crawl. How does that happen? The answer lives deep in the Linux kernel, in the CFS bandwidth controller and cgroups, and most teams never look there. Requests and limits are…
more -
Should We Rewrite Node.js in Rust?
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…
more -
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...
-
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…
more -
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...
-
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…
more -
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...
-
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…
more -
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...
-
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…
more -
Why Node.js Is the Critical Enabler for AI Applications
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…
more -
Kubernetes Finally Gets Vercel-Style Deployment Safety
Every deployment is a gamble. A user mid-session hits a new backend. A renamed field breaks a form. A shared TypeScript interface diverges between client and server, and suddenly your support queue is full, and three teams are in a bridge call trying to figure out who broke what. This is version...
-
From Black Box to Transparent: Building Auditable AI Apps
AI adoption is accelerating across enterprises, powering automation and smarter decisions. But without auditability, AI quickly turns into a black box. Hard to trust, and difficult to govern. Transparent, traceable AI is not optional. It’s how you build trust, reduce risk, and meet real-world...
-
Double the Density. Half the Memory (with James Snell)
Node.js performance discussions usually revolve around CPU and latency. Memory often receives less attention. But memory footprint directly affects cost, scalability, cold starts, and container density. Cutting memory usage in half fundamentally changes how efficiently you can run Node.js in...
-
Caching in the Enterprise: Why Most Companies Aren’t Doing It
Performance in enterprise systems isn’t just about fast code. It’s about making the right architectural choices. Surprisingly, caching is still often skipped, leaving applications slower, more expensive, and harder to scale. In this episode of The Node (& More) Banter, Luca Maraschi and Matteo...
-
HTTP, Queues, Actors: Watt Keeps Node.js Running Smoothly
Running HTTP requests and consuming messages from queues or brokers in the same Node.js process may seem convenient—but it often leads to unpredictable latency, resource contention, and fragile systems. In this episode of The Node (& More) Banter, Luca Maraschi & Matteo Collina explore how...
-
Scaling Node.js with the Right Signals: ELU, Kafka, and Kubernetes
Node.js performance in production isn’t about a single number — it’s about understanding the signals that drive scaling, stability, and cost. Event Loop Utilization (ELU) sounds simple, but once you add Kafka consumers, Kubernetes autoscaling, streams, and worker threads, things get complicated...
-
GraphQL in the Enterprise: Debunking the Myths About Its 'Niche' Problem
Recently, GraphQL has been under the spotlight, especially in the enterprise context. There’s been a lot of debate about whether it truly solves pressing problems or introduces more complexity than it’s worth. In this episode of The Node (& More) Banter, we go point by point and challenge these...
-
When Recursion Crashes Your App: The Async Hooks DoS Nobody Expected
JavaScript applications have long relied on a simple assumption: when recursion goes too far, the runtime throws a catchable error and the server survives. But under the hood, that assumption was never guaranteed — and with async context tracking enabled, it completely breaks. In this episode of...
-
The JAMstack Is Dead. Long Live the Runtime!
Markdown in Git sounds like the simplest possible way to manage content. No CMS. No dashboards. No abstractions. Just files, version control, and AI agents that can grep the codebase. But once content needs to scale — across pages, teams, products, and automation — that simplicity starts to…
more -
Inside the React RCE: What the Flight Vulnerability Really Reveals
The latest vulnerabilities in React Server Functions and the React Flight Protocol highlight just how fragile modern serialization can be. When insecure prototype access escalates into remote code execution, it’s not just a bug — it’s a wake-up call for anyone building with server-driven React.…
more -
The Node.js (R)evolution started - AWS just made it official
Running Node.js in serverless environments should be simple: deploy a function, let AWS scale it, and forget about infrastructure. But when you introduce multi-concurrency, shared worker threads, global state risks, and CPU-bound workloads — it’s not that simple. In this episode of The Node (&...
-
93% Faster Next.js: What Our Benchmarks Really Reveal About Next.js at Scale
Running Next.js in Kubernetes should be simple: containerize, replicate, autoscale. But under real traffic — thousands of requests per second, CPU-bound workloads, unpredictable spikes — it’s not that simple. In this episode of The Node (& More) Banter, Luca Maraschi and Matteo Collina unpack our...
-
When Rendering Blocks: How Next.js Internals Stress the Node.js Event Loop
Last week, we talked about the complexity of running Next.js at enterprise scale. This week, we’re going under the hood — into the rendering engine itself. In this episode of The Node (& More) Banter, Luca Maraschi & Matteo Collina break down how Next.js’s server-side rendering model actually...
-
Next.js at Scale: The Hidden Challenges of Enterprise Adoption
Next.js started as the easiest way to build React apps. But once you cross into enterprise scale — millions of users, regional deployments, complex caching, and security constraints — things get… complicated. In this episode of The Node (& More) Banter, Luca Maraschi & Matteo Collina dive deep…
more -
React's New Era: Compiler Magic, Native Architecture, and Foundation Shift
From React Compiler 1.0 introducing automatic memoization (no more useMemo debates), to React Native deleting its legacy architecture and running directly on C++, to the entire React project moving under the Linux Foundation — the ecosystem is undergoing its biggest transformation since Hooks. In...
-
Workflow Wars: From Kafka Chaos to Durable Dreams
Every Node.js developer has, at some point, built a “distributed system” that turned into a distributed headache. You start with Kafka and a few services, and before long, you’re juggling retries, compensations, and correlation IDs like it’s 3 AM in production. In this episode of The Node (&…
more -
The Node (& More) Banter: Special — The Best of Node.js Conversations
Every Node.js developer has tuned into "𝐓𝐡𝐞 𝐍𝐨𝐝𝐞 (& 𝐌𝐨𝐫𝐞) 𝐁𝐚𝐧𝐭𝐞𝐫" to learn, laugh, and uncover the stories shaping how we build software — and this time, we’re doing something different. In this Special Episode, we highlight Luca Maraschi & Matteo Collina's most impactful moments...
-
Seeing the Full Picture: Heap Profiling for Node.js Apps
Every Node.js developer has chased down a slow endpoint or a CPU hotspot — but what about memory leaks silently draining your app’s performance (and your cloud budget)? In this episode of The Node (& More) Banter, Luca Maraschi & Matteo Collina dive into one of the most exciting updates to the...
We're indexing this podcast's transcripts for the first time — this can take a minute or two. We'll show results as soon as they're ready.
No matches for "" in this podcast's transcripts.
No topics indexed yet for this podcast.
Loading reviews...
ABOUT THIS SHOW
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.
HOSTED BY
Platformatic
CATEGORIES
Loading similar podcasts...
Frequently Asked Questions
How many episodes does The Node (and more) Banter have?
The Node (and more) Banter currently has 81 episodes available on PodParley. New episodes are automatically indexed when they're published to the podcast feed.
What is The Node (and more) Banter 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...
How often does The Node (and more) Banter release new episodes?
The Node (and more) Banter has 81 episodes. Check the episode list to see recent publication dates and frequency.
Where can I listen to The Node (and more) Banter?
You can listen to The Node (and more) Banter on PodParley by clicking any episode. We provide an embedded audio player for direct listening, and you can also subscribe via your preferred podcast app using the RSS feed.
Who hosts The Node (and more) Banter?
The Node (and more) Banter is created and hosted by Platformatic.
URL copied to clipboard!