Shows
The Node (and more) BanterWhat Deno Gave Node.jsDeno joined Cloudflare, and with the runtime winding down over the next year, Luca and Matteo look back at what it leaves behind.Deno pioneered web standards on the server and did the hard work of adapting fetch for Node.js, collaborated on Node’s own design decisions, and pushed the whole ecosystem forward.They also give it an honest postmortem: the two wild bets that didn’t survive contact with reality (URL-based package resolution and the “secure by default” permission model), and why trying them was still the right call.
2026-10-2827 minThe Node (and more) BanterNo, we should not distribute TypeScript filesJarred 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 TypeScript. Porffor solved it by compiling JavaScript and keeping every check. Bun is trying to sit in the middle, and the middle is where the problems live: TypeScript is not one language but a multiverse of them depending on...
2026-10-2133 minThe Node (and more) BanterNodeConf 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 CRA, and a Tokio PR.Luca and Matteo debrief the whole thing. The talks that landed, the ones they are still chewing on, and what changes for 2027.
2026-10-1430 minThe Node (and more) BanterDo 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 something gives. Where does it hold? Where does it fall apart? If it is true, what happens to review, to ownership, to the junior who is still learning the craft? No conclusions...
2026-10-0729 minThe Node (and more) BanterThe Sandbox Was Fine. JavaScript Wasn'tOn 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 reported on August 12 and fixed in eight days.The headline claims the sandbox was escaped, but Matteo and Luca, looking at it from a Node.js perspective, see a different story. The macOS sandbox actually worked. The real problem was with the JavaScript inside: Op...
2026-09-3031 minThe Node (and more) BanterState Without a LandlordWorkflows 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 within your own network.This episode explains the origin of the idea, how the various components fit together, and tells the enterprise why it should question the fact that its agentic workloads are leaving the building.
2026-09-2328 minThe Node (and more) BanterImagine 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.
2026-09-1636 minThe Node (and more) BanterThe HTTP/2 Bugs Hiding in Plain SightMost 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 balancer advertises HTTP/2, you’ve switched over without changing any code.In this episode of The Node (and more) Banter, Luca Maraschi and Matteo Collina talk about th...
2026-09-0925 minThe Node (and more) BanterWill 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 this episode of The Node (and more) Banter, Luca Maraschi and Matteo Collina argue that AI increases the need for foundational infrastructure. AI can generate code, but it doesn't account for Event-Loop Utilization. It...
2026-09-0231 minThe Node (and more) BanterEvery 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; it’s that the system keeps forgetting.In this episode of The Node (and more) Banter, Luca Maraschi and Matteo Collina talk with Ivan Tymosh...
2026-08-2631 minThe Node (and more) BanterWho 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 Matteo decided to run AI models locally. Luckily, the creator of Redis had already built just what he needed.In this episode of The Node (and more) Banter, Luca Maraschi and Matteo Collina talk...
2026-08-1933 minThe Node (and more) BanterShould 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 Maraschi and Matteo Collina dig into one of the most counterintuitive findings they've encountered while working with a...
2026-08-1227 minThe Node (and more) BanterNitro 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 episode of The Node (and more) Banter, Luca Maraschi and Matteo Collina talk with Paolo Insogna, Principal Software Engineer at Platformatic, about @platformatic/ni...
2026-08-0526 minThe Node (and more) BanterYour Bug Fix Will Never Reach the Runs That Need ItYou 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) Banter, Luca Maraschi and Matteo Collina discuss Platformatic’s new research paper on the Workflow Upgrade Risk model, or WUR. This data-driven method...
2026-07-2930 minThe Node (and more) BanterAre 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 possible.In this episode of The Node (and more) Banter, Luca Maraschi and Matteo Collina are joined by Paolo Insogna, Principal Software Engineer at Platformatic. Together, they walk through every integration point between...
2026-07-2227 minThe Node (and more) BanterIs 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. So who ends up paying for all this?In this episode of The Node (and more) Banter, Luca Maraschi and Matteo Collina talk about their daily work with the...
2026-07-1528 minThe Node (and more) BanterYour Node.js Gateway It's Doing Twice the WorkYou 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?In this episode of The Node (and more) Banter, Luca Maraschi and Matteo Collina are joined by Paolo Insogna, Principal Software Engineer at Platformatic...
2026-07-0830 minThe Node (and more) BanterHow 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 break down the version skew problem from scratch. They explain what really happens during a deployment, why forcing a reload isn’t an option, and how to...
2026-07-0138 minThe Node (and more) BanterWhy 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 about version skew: what it is, why it naturally happens when you ship isomorphic JavaScript apps, and why most teams don’t set up skew pr...
2026-06-2427 minThe Node (and more) BanterNode.js Left 26% Performance on the Table for 10 YearsA 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 Collina explain how they investigated a small but important change that was just released in Node.js 26.3.0. They discuss how modern applications moved...
2026-06-1731 minThe Node (and more) BanterPerformance/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 runtime if it becomes an issue. They use flame graphs on Kafka workloads to reveal hidden bottlenecks and explain a clear approach that makes memory debugging more...
2026-06-1035 minThe Node (and more) BanterHow 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 entirely. So what does rate limiting that actually holds across a cluster look like?In this episode of The Node (and more) Banter...
2026-06-0330 minThe Node (and more) BanterRequests, Limits, and the Throttling Trap: K8s Resources for Node.jsYou 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 them is how you end up paying for CPU you can never actually use. So how do you size them right for an event-loop runtime?
2026-05-2728 minThe Node (and more) BanterShould 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 Bun Zig-to-Rust port, including the memory leaks that led to the change, the rumors around it, and what it means that...
2026-05-2029 minThe Node (and more) BanterWe 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, wi...
2026-05-1336 minThe Node (and more) BanterPredictive Autoscaling for Node.js: Why Reactive Systems Are Costing You More Than You ThinkMany 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...
2026-05-0636 minThe Node (and more) BanterSandboxing Ai Agents in Kubernetes: Why Regina Uses eBPF and Not a VMRunning 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...
2026-04-2931 minThe Node (and more) BanterAi Agents, Kubernetes, and the Sandbox That Now Runs Inside Your ClusterMost 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...
2026-04-2234 minThe Node (and more) BanterTanStack 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 Wa...
2026-04-1550 minThe Node (and more) BanterSkills, Agents & the Setup That Actually Works for AI-assisted JS DevelopmentMost 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...
2026-04-0843 minThe Node (and more) BanterBringing @workflow to your KubernetesWorkflows 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 Wo...
2026-04-0129 minThe Node (and more) BanterNode.js VFS: Unlocking Dynamic Code, Testing, and Multi-TenancyNode.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 s...
2026-03-2530 minThe Node (and more) BanterWhy Node.js Is the Critical Enabler for AI ApplicationsAI 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 developers to use?In this episode of “The Node (and more) Banter,” Luca Maraschi and Matteo Collina talk about why Node.js has become a key instrument for modern AI applications. Whether it’s managing LLM APIs...
2026-03-1838 minThe Node (and more) BanterKubernetes Finally Gets Vercel-Style Deployment SafetyEvery 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 The Node (& More) Banter, Luca Maraschi and Matteo Collina introduce Skew Protection in Platformatic's Intelligent Command Center (ICC), bringing the deployment safety that frontend teams...
2026-03-1130 minThe Node (and more) BanterFrom Black Box to Transparent: Building Auditable AI AppsAI 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 down how to build AI apps that are fast, scalable, and crucially auditable while taking advantage of Platformatic OpenSource. We go deep into real strategies: designing for traceability, logging every decision, and making AI...
2026-03-0434 minThe Node (and more) BanterDouble 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 James Snell, Principal System Engineer at Cloudflare, core contributor to Node.js, and member of the Node.js Technical Steering Committee. Together, they unpack how we reduced Node.js memory consumption by 50 percent and what...
2026-02-2535 minThe Node (and more) BanterCaching in the Enterprise: Why Most Companies Aren’t Doing ItPerformance 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 enterprises can adopt it effectively without adding complexity.We’ll explore:✅ The main reasons companies avoid caching, and whether those reasons hold up✅ How caching im...
2026-02-1830 minThe Node (and more) BanterHTTP, Queues, Actors: Watt Keeps Node.js Running SmoothlyRunning 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.We’ll dive into:✅ Why mixing HTTP and queue workloads can hurt reliability and throughput✅ How Watt allows you to isolate workloads while fully leveraging Node.js’ event loop and t...
2026-02-1131 min
JavaScript JabberNode.js Performance, Kubernetes, and Why “Fast” Isn’t Always Fast - JSJ 702In this episode of JavaScript Jabber, I sat down with Matteo Collina—chair of the Node.js project and founder of Platformatic—for a deep, no-fluff conversation about Node.js performance in the real world. We dug into what actually happens when you run Node at scale, especially with server-side rendering, Kubernetes, and modern frameworks like Next.js.We also challenged some popular assumptions—like whether newer runtimes automatically mean better performance—and explored how benchmarking, flame graphs, and smarter scheduling can completely change the reliability of production systems. If you’re running Node in Kubernetes, doing SSR, or trying...
2026-02-101h 20The Node (and more) BanterScaling Node.js with the Right Signals: ELU, Kafka, and KubernetesNode.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 metrics through the lens of real-world, event-driven systems. We focus on how ELU behaves in Kafka-heavy workloads, how it correlates with CPU, memory, and I/O, and why choosing the right metrics matter...
2026-02-0440 minThe Node (and more) BanterGraphQL in the Enterprise: Debunking the Myths About Its 'Niche' ProblemRecently, 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 enterprise setups, it still brings massive value.Join Luca Maraschi and Matteo Collina as they break down:✅ Why overfetching isn’t fully solved by BFFs✅ How Gr...
2026-01-2833 minThe Node (and more) BanterWhen Recursion Crashes Your App: The Async Hooks DoS Nobody ExpectedJavaScript 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 bug that turned deep recursion into an unrecoverable process crash. A subtle interaction between stack exhaustion and async_hooks caused Node.js to exit immediately — bypassing try/catch, uncaughtException, and any chance of graceful recovery. The...
2026-01-2135 minThe Node (and more) BanterThe 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. And before long, you’re running a backend again.In this episode of The Node (& More) Banter, Luca Maraschi & Matteo Collina unpack the debate sparked by “You should never build a CMS” — and explain why deleting the CMS doesn’t...
2026-01-1439 minThe Node (and more) BanterInside the React RCE: What the Flight Vulnerability Really RevealsThe 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 disclosed React/Next.js RCE vulnerabilities and what they reveal about the complexity hidden inside today’s server-side React architectures. No blame, no sensationalism — just a clear explanation of what happened and why it...
2025-12-1729 minThe Node (and more) BanterThe Node.js (R)evolution started - AWS just made it officialRunning 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:Invent: the new Node.js runtime for Lambda Managed Instances. AWS is officially validating what Platformatic has been saying for months — Node.js is entering a multi-concurrency era, and most applications are not re...
2025-12-1031 minThe Node (and more) Banter93% Faster Next.js: What Our Benchmarks Really Reveal About Next.js at ScaleRunning 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 single-CPU pods. We go beyond charts to explain why the results happen, from Node.js event-loop behavior to Kubernetes load distribution and the Linux kernel’s SO_REUSEPORT.We'll cover:✅ How...
2025-12-0341 minThe Node (and more) BanterWhen Rendering Blocks: How Next.js Internals Stress the Node.js Event LoopLast 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.We’ll explore:✅ How SSR, RSC, streaming, and data-fetching all compete for the same event loop✅ Why heavy render passes can starve I/O and cause tail latencies unde...
2025-11-2631 minThe Node (and more) BanterNext.js at Scale: The Hidden Challenges of Enterprise AdoptionNext.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 takes to make it fast, reliable, and maintainable when “just deploy it” doesn’t cut it anymore.We'll cover:✅ The hidden complexity of distributed rendering and Incremental Static Regeneration (ISR), and the new use cache direct...
2025-11-1940 minThe Node (and more) BanterReact's New Era: Compiler Magic, Native Architecture, and Foundation ShiftFrom 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 shifts mean for developers today — and what’s coming next.We’ll cover:✅ How React Compiler makes your apps faster without changing a line of code✅ Why React Native’s new architecture is a complete rebuild, not a...
2025-11-1235 minThe Node (and more) BanterWorkflow Wars: From Kafka Chaos to Durable DreamsEvery 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 o...
2025-11-0549 minThe Node (and more) BanterThe Node (& More) Banter: Special — The Best of Node.js ConversationsEvery 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
2025-10-2954 minThe Node (and more) BanterSeeing the Full Picture: Heap Profiling for Node.js AppsEvery 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.
2025-10-2227 minThe Node (and more) BanterNode.js Loves Python: Running ASGI Apps Inside Your Node.js ServicesPython 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...
2025-10-1536 minThe Node (and more) BanterInside 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 ma...
2025-10-0839 minThe Node (and more) BanterThe Myths (and Costs) of Running Node.js on KubernetesKubernetes 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...
2025-10-0133 minThe Node (and more) BanterFrom Reactive to Predictive: Smarter Node.js Operations at ScaleFor 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 firef...
2025-09-2440 minThe Node (and more) BanterType-Safe API Clients: The Future of IntegrationAPIs 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...
2025-09-1741 minThe Node (and more) BanterThe 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 s...
2025-09-1043 minThe Node (and more) BanterReading the Fire: Flamegraphs and the Hunt for Node.js BottlenecksYou 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 cove...
2025-09-0344 minThe Node (and more) BanterStop Reinventing the Wheel: Mastering HTTP CachingWhen 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 refetching✅ Common mistakes that lead teams to build fragile, homegrown caching hacks✅ How proper HTTP caching strategies improve scalability...
2025-08-2740 minThe Node (and more) BanterThe danger of SetImmediateAt 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:✅ How setImmediate() really works (vs setTimeout and process.nextTick)✅ Common pitfalls that can silently break your logic✅ Real-world...
2025-08-2032 minThe Node (and more) BanterThe 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’ll dig into:✅ What async context really is (and what it isn’t)✅ Why it breaks in production, especially under load...
2025-08-1352 minThe Node (and more) BanterStateful by Design: Rethinking Team AI Workflows with AI-WarpAI 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 used it to build a Slack bot that lets our team pick up, share, and continue AI conversations—without losing context or flow.We’ll dig into...
2025-08-0641 minThe Node (and more) BanterMCP: 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 & CPO of Cerbos, to explore how MCP is reshaping how teams think about interoperability, policy, and context-aware behavior. We also go behind the scenes on our effort to bri...
2025-07-3045 minThe Node (and more) BanterThe Illusion of Standardization: Templating Gone WildIn 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 efforts to standardize often backfire, and how the dream of "just use the template" slowly erodes into chaos.We’ll explore:Why starter kits rarely stay aligned with realityHow templating introd...
2025-07-2340 minThe Node (and more) BanterThe 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 the app. Roberto Bianchi, Staff Engineer at Spendesk, joins us to share what his team learned as they experimented moving away from a sidecar-heavy setup—and how Watt can help simplifying operations and boost performance.
2025-07-1649 minThe Node (and more) BanterRuntime Composition: The Missing LayerComposable 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 languages, processes, and systems.Topics include:✅ Why runtime composition matters more as stacks become more distributed✅ Running multiple runtimes (Node, PHP, WASM) together, intentionally✅ How orchestration at the execution layer be...
2025-07-0948 minThe Node (and more) BanterThe Platform TrapInternal 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✅ How internal tools silently shape team structure and velocity✅ The fine line between empowering developers and creating lock-in✅ The rise of runtime-aware platforms and why they might offer a better pathIf yo...
2025-07-0251 minThe Node (and more) BanterMake vs Build: The Architecture ForkIn 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 tools✅ When PaaS simplifies operations—and when it limits you✅ Why on-prem isn't dead, especially for control and cost at scale✅ The illusion of no-code glue and the burden it shifts to d...
2025-06-2747 minThe Node (and more) BanterYour Stack Is Charging YouModern 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 and performance✅ How frontend frameworks aren’t solving orchestration, just shifting the pain✅ Where caching helps—and where it makes things worseWe’ll also reflect on what the MACH movement (M...
2025-06-2451 minThe Node (and more) BanterThe 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 introduced by over-network composition, and fragile coupling to backend services.We’ll also dive into practical solutions:✅When to use a BFF and when to consolidate✅How caching can save or sink your BFF...
2025-06-2047 minThe Node (and more) BanterNode loves PHP: Reuniting Web’s Power Duo for the Microservices EraPHP 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 backend architecture. We talk about:✅ Why PHP still powers critical workloads across the internet✅ How we enabled PHP to run inside wo...
2025-06-2055 minThe Node (and more) BanterFrom Sensors to Sentience: Making APIs AI-Ready in the Age of Smart DevicesThe 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 shift from request-response to long-lived, state-aware connections.✅ Why protocols like MQTT are foundational for real-time, resilient device communication.✅ The architecture implications of resumable sessions, e...
2025-06-2041 minThe Node (and more) BanterCommand Query Responsibility Segregation (CQRS) and Event SourcingIn 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 scalability — we also discuss when these patterns introduce more complexity than value. You’ll learn:✅The core principles of CQRS and Event Sourcing✅Real-world use cases where they shine (think audit logs...
2025-06-2053 minThe Node (and more) BanterMicroservices and KafkaIn 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 scale with confidence.What you’ll learn:✅A developer-friendly introduction to Apache Kafka✅Why communication between microservices is the #1 source of complexity✅How to design services that communicate through even...
2025-06-2052 minThe Node (and more) BanterA deep dive into the OpenAPI SpecificationThe 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 from OpenAPI ✅ Best practices for writing and maintaining specs✅ Using OpenAPI in CI/CD pipelines✅ Versioning and collaboration workflows with OpenAPI
2025-06-2053 minThe Node (and more) BanterDistributed Systems Series: Authentication and Authorization Part 2Secure 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 with practical knowledge and actionable strategies to fortify your systems without compromising performance.Topics we will cover in Part 2:✅ Zero Trust architecture: Moving beyond perimeter security in distributed systems✅ Managing service-to-service authentication securely across system boundaries✅ Advanced threat...
2025-06-2053 minThe Node (and more) BanterDistributed Systems Series: Authentication and Authorization Part 1Secure 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 with practical knowledge and actionable strategies to fortify your systems without compromising performance.Topics we will cover in Part 1: ✅ Modern token-based authentication patterns for distributed systems (OAuth 2.0, JWT, PASETO) ✅ Implementing authorization at scale: RBAC vs. ABAC approaches in microservice envi...
2025-06-2048 minThe Node (and more) BanterA Deep Dive into Fastify with Tomas Della VedovaWhat 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 without sacrificing DX✅ Plugin architecture and ecosystem✅ Where Fastify fits into modern backend stacks✅ What’s coming next in the Fastify roadmap
2025-06-2056 minThe Node (and more) BanterHow 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 alerting✅ Tips for managing service dependencies and versioning
2025-06-2059 minThe Node (and more) BanterScaling Node.js: Microservices & KubernetesAs 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 into microservices✅ How Kubernetes actually runs your Node.js services behind the scenes ✅ How to structure and deploy Node.js services in a Kubernetes environment✅ Common mista...
2025-06-2051 minThe Node (and more) BanterDeploying 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 grows with you.We'll cover:✅ Setting up an AWS EKS cluster for Node.js applications✅ Scaling and load balancing best practices✅ How to optimize security and performanc...
2025-06-201h 01The Node (and more) BanterUnpacking Config & Env Variables in Node.jsEver 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 practices for managing environment variables ✅ Securing secrets & avoiding common pitfalls ✅ Environment-specific configurations & dynamic loading strategies✅ How mismanaged env variables can lead to se...
2025-06-201h 02The Node (and more) BanterA guide to building stateful distributed systemsModern 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 effectively✅ Best practices for data consistency, replication, and failover✅Running stateful applications on Kubernetes
2025-06-2050 min
Gitbar - Italian developer podcastEp.207 - Watt con Matteo Collina e Paolo Insogna (Platformatic)# Note dell'episodioIn questa puntata ci addentriamo nel mondo delle startup, del software open source e dell’innovazione con Matteo Collina e Paolo Insonnia di Platformatic. Insieme, riflettiamo sulla differenza tra lavoro in consulenza e sviluppo di prodotto, dove il rischio è alto, ma le possibilità di crescita e impatto sono altrettanto grandi. Matteo condivide la sua esperienza nell'avviare una startup, evidenziando i rischi finanziari e il "countdown" che ogni realtà imprenditoriale affronta fino a raggiungere la sostenibilità economica.Parliamo dell’open source, delle sfide etiche e commerciali che comporta e di come bilanciare la libertà del codice aperto con la ne...
2024-11-141h 24
PodRocketHow Platformatic is simplifying Node.js app management with Matteo Collina and Luca MaraschiMatteo Collina and Luca Maraschi join the podcast to talk about Platformatic. Learn about Platformatics’ incredible 4.3 million dollar seed round, its robust features and modular approach, and how it addresses the unique challenges faced by devs and enterprises.
Links
https://platformatic.dev/docs/getting-started/quick-start-watt
Matteo Collina:
https://nodeland.dev
https://x.com/matteocollina
https://fosstodon.org/@mcollina
https://github.com/mcollina
https://www.linkedin.com/in/matteocollina
https://www.youtube.com/@adventuresinnodeland
Luca Maraschi:
https://www.linkedin.com/in/lucamaraschi
https://x.co...
2024-11-0735 min
Fireside with VoxgigEpisode 205 Matteo Collina returns, Platformatic Co-Founder and CTOOur guest today is none other than the wonderful Matteo Collina. Matteo is a returning guest on the podcast, and we are so excited to catch up with him. There's a lot of ground to cover here, including philosophy, the highs and lows of being a maintainer, and the world of TypeScript.
Matteo leads us in a discussion of testing infrastructure. The sequence of events should be simple. Write an application, write a test for it. But when the test doesn't accurately reflect the running environment, the results won't be of much use. Some tests may be good for determining...
2024-08-301h 01
Fireside with VoxgigEpisode 199 Tejas Kumar (repeat) Chief Developer AdvocateWe're nearly at our 200th episode! As that day approaches, we invite you to listen to this throwback from last year of Richard's discussion with Tejas Kumar. We'll be back next week with a brand new guest for you to enjoy and learn from!
Richard and Tejas cover fresh ground in today's episode.
Watch out for the discussion of DevRel vs DevSell. Tejas talks us through the difference. And he gives wonderful insights in to an often under valued need – how to pace yourself at conferences. To be able to do this is crucial for physical and mental health.
Reach ou...
2024-08-0833 min
Mechanical Ink PodcastNavigating Node.js Security: A Conversation with Matteo CollinaIn a riveting episode of the Mechanical Ink podcast, host Schalk Neethling welcomed Matteo Collina, a luminary in the Node.js community whose work has amassed over 22 billion downloads on npm in 2023 for the various open source modules he maintains. This episode was not just a deep dive into the technical intricacies of Node.js but also an enlightening discourse on the security landscape, community engagement, and the future of back-end development with the introduction of Platformatic. Here's a closer look at the discussions that made this episode a must-listen for developers.Community at the Heart of...
2024-03-1744 min
devtools.fm: Developer Tools, Open Source, Software DevelopmentMatteo Collina - Node.js, Fastify, PlatformaticThis week we talk with Matteo Collina about his background, contributions to the Node.js community, and his work on Fastify and Platformatic. Matteo is a prolific open source contributor and maintainer of many popular projects including Fastify, Pino, Mercurius, Avvio, and fast-json-stringify. He is also a Node.js TSC member and on the board of the OpenJS Foundation. Join us as we discuss the current state of Node.js, the future of JavaScript runtimes, and the importance of open source sustainability.
https://github.com/mcollina
https://nodeland.dev/
https://twitter.com/matteocollina
Episode sponsored By Raycast...
2023-11-271h 10
The Leadership ExchangeEmbracing Risk and Doing Your Part in Open Source: Lessons from Platformatic CTO Matteo CollinaRob Ocel talks to Matteo Collina, Platformatic's co-founder and CTO, about leadership and risk perception. Matteo discusses how Platformatic manages risk using their tools and emphasizes the overlooked advantages of embracing open source contributions in organizations.
Sponsored by This Dot Labs.
2023-11-2123 min
Behind the GrowthLuca Maraschi on Revolutionizing Backend DevelopmentIn the latest episode of Behind the Growth, host Mudassar Malik is joined by Luca Maraschi, Co-Founder and CEO of Platformatic. Luca shares his rich career journey, from working in various roles in different industries, including gaming and tech, to founding and exiting various companies. Luca discusses the importance of different perspectives, emphasizing how working with large customers across various verticals has been a significant source of inspiration for him. He highlights his belief that working with great people and drawing inspiration from them is essential in building successful startups. The conversation shifts to the in...
2023-10-1039 min
Buongiorno da EdoPlatformatic v1.0.0, e aggiornamenti su Unity - Buongiorno 136Celebriamo il lancio di Platformatic v1.0.0, cerco di sintetizzare un po' cos'è il progetto di Matteo Collina e cosa contiene la versione 1, e poi qualche aggiornamento sul caso Unity.
#platformatic #javascript #unity #gaming #opensource
===
Podcast
Anchor - https://anchor.fm/edodusi
Spotify - https://open.spotify.com/show/4B2I1RTHTS5YkbCYfLCveU
Apple Podcasts - https://podcasts.apple.com/us/podcast/buongiorno-da-edo/id1641061765
Google Podcasts - https://podcasts.google.com/feed/aHR0cHM6Ly9hbmNob3IuZm0vcy9iMWJmNDhhMC9wb2RjYXN0L3Jzcw
Amazon Music - https://music.amazon.it/podcasts/5f724c1e-f318-4c40-9c1b-34abfe2c99...
2023-09-2712 min
PodRocketSvelte 4, Kent C. Dodds, and Matteo CollinaIn this week’s roundup, hear snippets of our discussions about the recent release of Svelte 4 with Geoff Rich, Kent C. Dodds explains his newest stack, The Epic Stack, and Matteo Collina explains modular monoliths.
Links
Apple
Svelte 4 with Geoff Rich: https://tinyurl.com/2tht8bu3
Matteo Collina on modular monoliths, Platformatic, and Pino: https://bit.ly/3CFD4id
The Epic Stack with Kent C. Dodds: https://bit.ly/3qMQGFG
Google
Svelte 4 with Geoff Rich: https://tinyurl.com/uw2295f4
Matteo Collina on modular monoliths, Platformatic, and Pino: ht...
2023-06-3013 min
PodRocketMatteo Collina on modular monoliths, Platformatic, and PinoMatteo Collina, Co-Founder and CTO of Platformatic, Node.js TSC member, and Lead Maintainer of Fastify, joins us again to talk about modular monoliths, his new backend development platform Platformatic, and many of his other projects including Pino.
Links
https://nodeland.dev
https://platformatic.dev
https://getpino.io
https://www.linkedin.com/in/matteocollina
https://twitter.com/matteocollina
Tell us what you think of PodRocket
We want to hear from you! We want to know what you love and hate about the podcast. What do you want...
2023-06-2130 min
Fireside with VoxgigEpisode 98 Tejas Kumar Chief Developer AdvocateYou won't need coffee after this! Plug in to Richard & Tejas's chat and soak up the energy.
Richard and Tejas cover fresh ground in today's episode.
Watch out for the discussion of DevRel vs DevSell. Tejas talks us through the difference. And he gives wonderful insights in to an often under valued need – how to pace yourself at conferences. To be able to do this is crucial for physical and mental health.
Reach out to Tejas here: https://www.linkedin.com/in/tejasq/
Also mentioned in this episode:
Vercel https://vercel.com/
Cloudflare https://www.cloudflare.com/
React https://react.de...
2023-06-0833 min
Gitbar - Italian developer podcastEp.151 - Platformatic con Matteo collina (Platformatic)Questa settimana è venuto a trovarci un amico Matteo Collina, con lui abbiamo parlato di Platformatic, Fastify e del mondo javascript. Questo episodio contiene anche qualche bold opinion. E' cosi che ci piace :D.## Supportaci suhttps://www.gitbar.it/support## Paese dei balocchi- https://amzn.to/3ld8Myt- https://amzn.to/3mYZoin- https://amzn.to/3yIWsZP- https://github.com/platformatic/unscalable-queue-system- https://www.pcmag.com/news/woman-uses-apple-airtag-to-watch-her-lost-luggage-bounce-around-town## Link amazon affiliatohttps://amzn.to/3XDznm1## Per favore a...
2023-03-161h 12
JS Party: JavaScript, CSS, Web DevelopmentLaunching Platformatic DB 🚀Patformatic co-founders Matteo Collina & Luca Maraschi join Amal & Chris to discuss their just-announced (and we mean just announced) open source database tool: Platformatic DB!
It’s a daemon that can turn any PostgreSQL, MySQL, MariaDB, or SQLite database into a REST and GraphQL endpoint. What makes it special is that it allows massive customization thanks to the flexibility of Fastify plugins.
Join the discussionChangelog++ members save 4 minutes on this episode because they made the ads disappear. Join today!Sponsors:Square – Develop on the platform that sellers trust. There is a...
2022-09-301h 02Changelog Master FeedLaunching Platformatic DB 🚀 (JS Party #245)Patformatic co-founders Matteo Collina & Luca Maraschi join Amal & Chris to discuss their just-announced (and we mean just announced) open source database tool: Platformatic DB!
It’s a daemon that can turn any PostgreSQL, MySQL, MariaDB, or SQLite database into a REST and GraphQL endpoint. What makes it special is that it allows massive customization thanks to the flexibility of Fastify plugins.
Discuss on Changelog News
Changelog++ members save 4 minutes on this episode because they made the ads disappear. Join today!
Sponsors
Square – Develop on the platform that sellers trust. There...
2022-09-301h 02
PointerPodcastPointer[119]: Da Fastify a Platformatic.dev - Con Matteo Collina🟢 Se vi siete mai trovati a lavorare con Node.js, avrete con ogni probabilità eseguito almeno una riga di codice scritta dal nostro ospite di oggi. Stiamo parlando di Matteo Collina, co-founder e CTO di Platformatic e autore di svariati progetti open source che vengono scaricati circa 12 miliardi di volte all'anno. 🧑💻L'episodio è stata un'ottima occasione per ripercorre la carriera di Matteo: dal dottorato svolto presso l'università di Bologna, passando dalla nascita di Fastify, gli anni in Nearform per arrivare all'ultima avventura, iniziata giusto qualche giorno fa con la nascita di Platformatic. 🚧Parlando di Fastify ci siamo addentrati nei dettagli più tecnici riguardant...
2022-09-221h 12