The Node (and more) Banter
The Node (and more) Banter is a weekly podcast featuring unfiltered conversations between Luca Maraschi and Matteo Collina. They explore edge cases, anti-patterns, and undocumented aspects of modern development, focusing on Node.js and related technologies. Episodes cover distributed architecture, platform pitfalls, and how enterprises approach building software. With sharp banter and real-world war stories, the show goes beyond Node.js to discuss everything around it.
Episodi
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 logical conclusion: maybe it's time to imagine a completely different world.
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 noticed. Undici 8 and Node 26 now automatically use HTTP/2 if the server prefers it, so if your internal load
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 disposable. Luca and Matteo challenge this view with benchmarks, white papers, and production experience.In t
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 means you get a period of slower performance while the pods catch up. The real issue isn’t the pattern; i
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 any time. This leaves open source maintainers and security researchers without good options. So Matt
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 story, and the other half can bring your app down.In this episode of The Node (and more) Banter, Luca Ma
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 worker health checks. Nitro handles the server, but someone still has to manage the whole fleet.In this epis
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 fix. That’s not a safety net. It’s a risk that never disappears.In this episode of The Node (and more) Ban
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 default. We built that missing piece, and in this episode, we share the full story of how Watt made it
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 access to the latest models they need to strengthen the core infrastructure that supports the AI industry. S
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 problem, and most teams only discover it the hard way. So what if your gateway could just... not do that
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 session.In this episode of The Node (and more) Banter, Luca Maraschi and Matteo Collina brea
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 are out of sync.In this episode of The Node (and more) Banter, Luca Maraschi and Matteo Collina talk ab
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 world that no longer existed.In this episode of The Node (and more) Banter, Luca Maraschi and Matteo C
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 the memory-performance tradeoff from two sides: how to plan for it during design, and how to handle it at
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 you thought you were allowing. That is not a smaller problem at scale, it is a different problem entire
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 not two knobs for the same thing. One drives scheduling, the other enforces a hard quota, and confusing
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 update?In this episode of The Node (and more) Banter, Luca Maraschi and Matteo Collina talk about the
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, tha
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 autosc
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 doe
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 th
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,
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
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 w
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 Collin
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 important infrastructure question: Which runtime can handle AI workloads at scale and still be easy for develop
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 skew, and it's been quietly slowing down engineering teams on Kubernetes for years.In this episode of T
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 compliance needs.On this episode of The Node (& More) Banter, Luca Maraschi and Matteo Collina break d
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 production.In this episode of The Node (& More) Banter, Luca Maraschi and Matteo Collina are joined by
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 Collina dig into why caching is so often overlooked, when it actually delivers value, and how enterpri
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 Platformatic Watt enables entirely new patterns for modern Node.js architectures, from sagas to actors
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 fast.In this episode of The Node (& More) Banter, Luca Maraschi and Matteo Collina dig into Node.js
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 assertions. GraphQL isn’t perfect, but many of these criticisms miss the bigger picture, and in real
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 Node (& More) Banter, Luca Maraschi and Matteo Collina dive into a recently disclosed Node.js bu
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 crack. Asset management sneaks back in. Permissions reappear. Content models emerge. Queries get rebuilt. An
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.In this episode of The Node (& More) Banter, Luca Maraschi and Matteo Collina break down the newly di
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 (& More) Banter, Luca Maraschi and Matteo Collina break down one of the biggest announcements from AWS re
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 latest benchmark showing Next.js running 93% faster with Watt compared to PM2 and traditional singl
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 behaves inside Node.js — and why certain rendering patterns can silently overwhelm your event loop.
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 into the real challenges of running Next.js in enterprise environments — and what it actually take
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 this episode of The Node (& More) Banter, Luca Maraschi & Matteo Collina unpack what these shif
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 tradi
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
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
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
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 acro
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.j
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 ope
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 becomin
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 man
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, o
Stop Reinventing the Wheel: Mastering HTTP Caching
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 refetchin
The danger of SetImmediate
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:✅ Ho
The Hidden Cost of Async Context in Node.js (with Bryan English)
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.We
Stateful by Design: Rethinking Team AI Workflows with AI-Warp
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 u
MCP: The New Interface of the AI Stack (with Alex Olivier)
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 &
The Illusion of Standardization: Templating Gone Wild
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 effo
The Hidden Cost of the Sidecar Pattern (with Roberto Bianchi)
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 th
Runtime Composition: The Missing Layer
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 la
The Platform Trap
Internal platforms were supposed to streamline development. Instead, many teams find themselves maintaining internal systems more complex than the apps they support.In this episode, we explore the platform trap—how well-meaning abstractions can evolve into burdens, and what separates effective internal platforms from over-engineered detours.We’ll dig into:✅ When “platform” becomes a second product
Make vs Build: The Architecture Fork
In today’s composable world, teams face a critical decision: make the pieces work together—or build the platform themselves. On paper, the flexibility is liberating. In reality, it comes with trade-offs that hit engineering velocity, cost, and maintainability.In this episode, we break down the models behind modern digital platforms:✅ The true cost of "just integrating" SaaS and headless
Your Stack Is Charging You
Modern architectures promise flexibility—mix the best services, swap parts anytime, go faster. But somewhere between headless CMSs, personalization engines, CDNs, and frontend frameworks... things start to drag.In this episode, we unpack the hidden cost of assembling your tech stack like LEGO:✅ Why delivering content at scale gets harder with every new service✅ The tension between personalization
The BFF Pattern: Glue or Liability?
In this episode, we take a hard look at the Backend-for-Frontend (BFF) pattern: why it was introduced, where it actually helps, and where it starts to fall apart in real-world microservices architectures.We explore the core problems BFFs were meant to solve—API orchestration, frontend-specific shaping, security boundaries—but also the unintended costs: duplication of business logic, latency introd
Node loves PHP: Reuniting Web’s Power Duo for the Microservices Era
PHP once ruled the web—and for good reason. Its simplicity and ubiquity made it the go-to runtime for millions of developers. But in today’s cloud-native world, Node.js has taken center stage for event-driven performance and modern tooling.At Platformatic, we’re not picking sides—we’re bridging them.In this episode, we dive into why PHP and Node.js aren’t rivals but the perfect pair for modern bac
From Sensors to Sentience: Making APIs AI-Ready in the Age of Smart Devices
The boundary between physical and digital is dissolving. With OpenAI reportedly partnering with Jony Ive to build next-gen AI-powered hardware, a new era of intelligent IoT devices is taking shape—one where APIs need to do more than just respond. They need to understand, predict, and adapt.In this episode, we explore what it takes to modernize traditional APIs for this future. We break down:✅ The
Command Query Responsibility Segregation (CQRS) and Event Sourcing
In this episode, we dive into two powerful architectural patterns that are often misunderstood: Command Query Responsibility Segregation (CQRS) and Event Sourcing. We unpack how CQRS can bring clarity and performance to complex systems by decoupling reads from writes, and how Event Sourcing allows you to track every state change as a series of immutable events.But it’s not all sunshine and scalabi
Microservices and Kafka
In this episode, we unpack the communication layer of microservices—arguably the most complex and critical part of distributed systems. We start with a clear introduction to Apache Kafka—what it is, how it works, and why it's become a cornerstone for decoupled, scalable systems. Then, we shift into real-world strategies for using Kafka to build reliable, event-driven Node.js services that can scal
A deep dive into the OpenAPI Specification
The OpenAPI Specification has become the standard for describing RESTful APIs — but its true power is often underutilized. In this deep dive, we’ll unpack what the spec can do, how to leverage it for automation, and how it fits into modern API-first development workflows.In this Episode, we’ll cover: ✅ What the OpenAPI Specification actually defines ✅ How to generate clients, servers, and docs fro
Distributed Systems Series: Authentication and Authorization Part 2
Secure your distributed systems against modern threats with our expert-led webinar on Authentication and Authorization.Join us as we dive deep into the complex challenges of identity management in distributed architectures and explore cutting-edge solutions that balance security with scalability. From token-based authentication patterns to zero-trust implementations, this session will equip you wi
Distributed Systems Series: Authentication and Authorization Part 1
Secure your distributed systems against modern threats with our expert-led webinar on Authentication and Authorization. Join us as we dive deep into the complex challenges of identity management in distributed architectures and explore cutting-edge solutions that balance security with scalability. From token-based authentication patterns to zero-trust implementations, this session will equip you w
A Deep Dive into Fastify with Tomas Della Vedova
What makes Fastify one of the fastest, most efficient web frameworks in the Node.js ecosystem?In this candid conversation, we’ll sit down with Tomas Della Vedova, lead maintainer of Fastify, to talk about performance, extensibility, and the future of backend development in JavaScript.In this episode, we’ll cover:✅ Fastify’s core design principles and why they matter✅ How to optimize performance wi
How do I maintain services in a distributed system?
In a distributed system, things will fail — the challenge is making sure your services can recover, scale, and still talk to each other effectively.In this episode , we'll cover:✅ Common failure modes in distributed systems — and how to handle them✅ Strategies for service-to-service communication at scale-When to use REST, GraphQL, or a mix of both✅ Observability essentials: tracing, logging, and
Scaling Node.js: Microservices & Kubernetes
As your Node.js applications grow, so do the challenges of scaling, deploying, and managing them efficiently. Microservices architecture, paired with Kubernetes, offers a powerful solution—but it’s not without complexity. Whether you're just getting started or looking to improve your current setup, this session will break down what you need to know:✅ When (and when not) to break a Node.js monolith
Deploying Node.js on AWS EKS....but make it scalable!
Modern Node.js applications demand more than just containerization — they need resilience, scalability, and observability from day one. In this episode, we’ll dive into how to harness the full power of AWS EKS to run Node.js apps at scale, with confidence. Whether you're migrating from a monolith or fine-tuning your microservices, this session will help you build a production-grade foundation that
Unpacking Config & Env Variables in Node.js
Ever deployed an app only to realize an environment variable was missing or misconfigured?Managing configuration in Node.js should be simple—but without the right approach, it can quickly become a security risk or a debugging nightmare.This week, we’re diving into how to properly handle environment variables and configuration in Node.js with special guest Liran Tal from Snyk!We’ll cover:✅ Best pra
A guide to building stateful distributed systems
Modern applications increasingly rely on stateful distributed systems for databases, messaging, and real-time processing. But managing state in a distributed environment is complex—how do you handle data consistency, scaling, and fault tolerance effectively?In this episode, we discuss:✅ The difference between stateless and stateful architectures✅ How to scale and manage stateful workloads effectiv
