The Node (and more) Banter

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 crack. Asset management sneaks back in. Permissions reappear. Content models emerge. Queries get rebuilt. An...

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 . In this episode of The Node (& More) Banter , Luca Maraschi and Matteo Collina break down the newly...

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 wor ker threads , global state risks , and CPU-bound workloads — i t’s not that simple. In this episode of The Node (& More) Banter, Luca Maraschi and Matteo Collina break down one of the biggest announcements from...

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 latest benchmark showing Next.js running 93% faster with Watt compared to PM2 and traditional sin...

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 behaves inside Node.js — and why certain rendering patterns can silently overwhelm your event loo...

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 into the real challenges of running Next.js in enterprise environments — and what it actually ta...

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 this episode of The Node (& More) Banter , Luca Maraschi & Matteo Collina unpack what these sh...

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) Banter , Luca Maraschi & Matteo Collina break down the workflow orchestration wars — from tr...

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 from across the season — from scaling Node.js operations to mastering HTTP caching, surviving npm...

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 Platformatic ecosystem: heap profiling support in @platformatic/flame and Watt Runtime . With he...

Python and Node.js are often treated as separate worlds—data science and AI in one, APIs and web services in the other. But what if you could run them together, seamlessly, in the same process ? In this episode of The Node (& More) Banter , Luca Maraschi & Matteo Collina dive into our latest release: @platformatic/python —a new way to bring Python ASGI apps directly into your Node.js workl...

The npm ecosystem just faced another major supply-chain attack —and it’s a wake-up call for every team building on open source. In this episode, we’re joined by Feross Aboukhadijeh , Founder & CEO of Socket , to unpack what happened, how these attacks work, and what developers and enterprises can do to defend against them. We’ll cover: ✅ How attackers infiltrate npm packages ✅ The ripple eff...

Kubernetes is often sold as the one-size-fits-all platform for scaling applications. But when it comes to Node.js, the reality looks very different : sluggish autoscaling, bloated cloud bills, and resource models that don’t align with Node’s event-driven nature. In this episode of The Node (& More) Banter , we cut through the hype and explore why Kubernetes isn’t always the perfect fit for Nod...

For enterprises, Node.js apps bring both agility and complexity. Over-provisioned clusters, slow autoscaling, and disconnected metrics can silently drive up costs and risk outages. The future lies in predictive operations : runtime-aware scaling, unified observability, and cache intelligence—all working together to keep systems fast and efficient. In this episode, we’ll explore how modern Node.js...

APIs are the backbone of modern applications —but how often do they break because of mismatched payloads or vague documentation? That’s where type safety comes in. Type-safe clients don’t just save you from runtime errors; they make development faster, safer, and way less stressful. In this episode, we explore why type-safe client generation matters , how it works under the hood, and why it’s beco...

Sticking to an outdated Node.js version might feel safe—but under the hood, it can be a ticking time bomb. From unpatched security flaws to missed performance boosts, the tradeoffs aren’t always obvious until it’s too late. In this episode, we’re joined by Erick Wendel to explore the hidden risks, technical debt, and missed opportunities that come from running on old Node.js releases— and why so m...

You can’t fix what you can’t see—and when it comes to performance issues in Node.js, flamegraphs are one of the most powerful tools you have. But what are they, really? And how do you actually use them? In this episode, we break down everything you need to know about flamegraphs—from the theory behind them to their implementation in Node.js. Whether you’re chasing event loop delays, CPU hotspots,...

When it comes to speeding up API calls, many developers jump straight into custom caching layers—rediscovering problems that HTTP solved decades ago. In this episode, we dig into why HTTP caching is still one of the most underused superpowers in web performance. You’ll learn: ✅ How standard HTTP cache headers (Cache-Control, ETag, Vary) can do the heavy lifting ✅ Why revalidation beats blind ref...

At a glance, setImmediate() seems like just another async tool in Node.js—but misuse it, and you could end up with unresponsive apps, delayed executions, or even missed events. In this episode, we break down why setImmediate() is often misunderstood, where it actually fits into the event loop, and the hidden performance and logic traps it can introduce in real-world applications. We’ll dig into:...

From background tasks to cross-request tracing, many developers rely on async context to glue state across their code. But under the hood? It’s fragile, unpredictable, and often a performance landmine. In this episode, we’re joined by Bryan English to dive into the lesser-known tradeoffs of async context management in Node.js—and how to build observability without breaking your app or your brain....

AI tools are everywhere—but sharing context, conversations, and outcomes across a team? That’s still a mess. From copy-pasting chat logs to syncing prompts over Slack, most teams are stitching together brittle workflows that don’t scale. In this episode, we dive into our latest release of AI-Warp, which brings stateful interactions and resumable connections to the table. We’ll walk through how we...

As enterprises race to integrate AI into their systems, a quiet shift is underway: the rise of the Model Context Protocol (MCP) as the de facto interface between models, services, and infrastructure. MCP isn’t just another wire format—it’s a way to give structure, semantics, and shared context to how systems communicate in the AI era. In this episode, we're joined by Alex Olivier, Co-founder &...

In the quest for consistency, platform teams often turn to templating—starter kits, golden paths, boilerplate generators. The goal? Faster onboarding, safer deployments, fewer surprises. The result? A growing zoo of subtly different snowflakes, broken assumptions, and yet another internal tool no one really wants to maintain. In this episode, we dig into the dark side of templating culture—why eff...

Sidecars were meant to isolate concerns and standardize infrastructure. Instead, many teams end up managing a growing fleet of proxies, daemons, and coordination glue that quietly slows everything down. In this episode, we uncover the sidecar trap—how a well-intentioned pattern can balloon into operational drag, and what happens when the architecture starts optimizing for the infrastructure, not t...

Composable architectures have focused heavily on APIs, services, and build-time integrations—but what about composition at runtime? In this episode, we explore the often-ignored layer of modern systems: how code actually runs, cooperates, and scales after deployment. We unpack the shift from static, pre-built delivery pipelines to runtime-aware platforms that dynamically orchestrate logic across l...