The Node (and more) Banter

The Node (and more) Banter

By PlatformaticTechnology
Download on the App Store

The Node (and more) Banter episodes

  • 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) Banter, Luca Maraschi & Matteo Collina break down the workflow orchestration wars — from traditional message queues to modern “durable execution” frameworks like Temporal and Vercel’s new “use workflow” directive.

    We’ll explore:

    ✅ Why every complex Node.js system eventually reimplements a workflow engine

    ✅ The pain points of Kafka-style event choreography (and how we got here)

    ✅ How Temporal brings “workflow as code” to JavaScript

    ✅ Why Vercel’s “use workflow” might make durability a language-level concept

    ✅ When to choose Kafka, Temporal, or “use workflow” — and how to mix them

    If you’ve ever asked yourself, “Why is this microservice talking to that one?”, this episode will help you see how the next generation of workflow tools is making distributed logic finally… durable.

    50 min
  • 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 from across the season — from scaling Node.js operations to mastering HTTP caching, surviving npm attacks, and redefining how developers build type-safe integrations.Across these highlights, you rediscover the insights, debates, and discoveries that shaped our year — and the future of modern Node.js development.


    We covered:

    ✅ Smarter Node.js operations — from reactive to predictive

    ✅ The hidden costs (and myths) of running Node on Kubernetes

    ✅ How type-safe APIs are changing integrations forever

    ✅ Lessons from the latest npm supply-chain attacks

    ✅ Why caching is still one of the most powerful tools in your stack

    ✅ And more moments that made us stop, think, and laugh along the way


    Whether you’ve been with us from the start or just discovered Banter, this special episode brings the best of the conversation together — 50 minutes of the smartest, funniest, and most insightful moments from The Node (& More) Banter.

    55 min
  • 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 Platformatic ecosystem: heap profiling support in @platformatic/flame and Watt Runtime. With heap profiling now built right in, developers can finally see where memory is going, why it’s not being freed, and how to fix it — all alongside CPU profiling.


    We’ll cover:

    ✅ Why memory leaks are so hard to catch (and how flamegraphs make them visible)

    ✅ How heap and CPU profiling work together for a full performance picture

    ✅ What’s new in @platformatic/flame and Watt’s profiling tools

    ✅ Real-world scenarios where heap profiling exposes hidden inefficiencies

    ✅ Best practices for using these tools in development and production


    If you’ve ever wondered why your app slows down over time or crashes under load, this episode will help you uncover the hidden story of your memory usage — and how to take back control.

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

    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 workloads.


    We’ll cover: 

    ✅ How @platformatic/python bridges Node.js and Python without costly proxies

    ✅ Why this matters for AI, data science, and gradual Python → Node migrations

    ✅ The Rust-powered foundation making cross-language HTTP blazing fast

    ✅ Real-world use cases: ML inference endpoints, automation tasks, and more

    ✅ What’s next for multi-runtime services in Platformatic


    If you’ve ever wished you could tap into Python’s ecosystem without leaving Node.js, this conversation will show you how the two can finally play nice together.

    37 min
  • Inside the Latest npm Attack (with Feross Aboukhadijeh)

    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 effects across the Node.js ecosystem

    ✅ Why traditional security tools often miss the real threats

    ✅ Practical steps to secure your dependencies

    ✅ How open source maintainers and enterprises can collaborate on better defences

    If your applications depend on npm (and they almost certainly do), this is a conversation you can’t afford to miss.

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

    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 Node.js workloads—and what teams can do about it.


    We’ll dig into:

    ✅ Why autoscaling lag hurts bursty Node.js traffic

    ✅ How CPU/memory limits clash with Node’s async model

    ✅ The hidden costs of “elastic” scaling in Kubernetes

    ✅ Why treating Node.js like Java leads to waste and inefficiency

    ✅ Smarter strategies for scaling Node.js effectively in the cloud


    If you’ve ever wondered why your Kubernetes setup feels slow, expensive, or unpredictable with Node.js, this conversation will help you rethink the defaults—and save both performance and money.

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

    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 operations help enterprises:

    ✅ Cut infrastructure costs by up to 30% with smarter scaling

    ✅ Prevent outages before they happen with Event Loop–aware monitoring

    ✅ Gain full-stack visibility—from Kubernetes to caching efficiency

    ✅ Shift from firefighting to proactive operations


    If you care about performance, cost, and operational clarity, this is the conversation you don’t want to miss.

    41 min
  • Type-Safe API Clients: The Future of Integration

    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 becoming essential for teams building complex systems in Node.js and beyond. From automated TypeScript definitions to schema-driven code generation, this is the roadmap to more predictable and maintainable integrations.

    We’ll cover:

    ✅ What “type-safe client generation” actually means

    ✅ How it eliminates guesswork and reduces integration bugs

    ✅ The role of OpenAPI and JSON Schema in generating trusted clients

    ✅ Real-world examples of broken integrations—and how type safety prevents them

    ✅ How type safety improves onboarding and long-term maintainability

    If you’ve ever wrestled with unclear API docs, runtime surprises, or the dreaded undefined is not a function, this episode is your guide to making API integration reliable—without slowing down your team.

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

    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 many teams delay the upgrade in the first place.

    We’ll dig into:

    ✅ How outdated versions silently impact performance and reliability

    ✅ The real security risks lurking in older releases

    ✅ Compatibility issues with modern libraries and tooling

    ✅ The gains you’re leaving on the table by not upgrading

    ✅ Practical strategies for safe, low-friction migrations

    ✅ The cultural, organizational, and technical reasons why teams resist updates

    If your Node.js stack hasn’t been updated in a while—or you’re weighing the risks of upgrading—this conversation will give you the clarity (and the push) you need.

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

    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, or blocking I/O, flamegraphs reveal what your app is really doing under the hood.


    We’ll cover:

    ✅ What flamegraphs are and how they visualize stack traces over time

    ✅ How they’re implemented in Node.js (using V8 and async hooks under the hood)

    ✅ How to generate and capture them in dev and production

    ✅ How to read them: interpreting stack height, width, and call depth

    ✅ Real examples of uncovering performance bottlenecks

    ✅ How we’ve built automated flamegraph capture into


    Platformatic WattIf you’ve ever struggled with unexplained latency, inconsistent P99s, or just want to understand your Node.js app at a deeper level—this episode is your crash course in seeing the invisible.

    45 min

About The Node (and more) Banter

From the publisher's feed

The Node (and more) Banter is your weekly dose of unfiltered, unscripted conversations between Luca Maraschi and Matteo Collina.