November 17 - 20, 2025
JSNation US
New York, US & Online

JSNation US 2025

See JS stars in the US biggest planetarium

Full remote ticket included with Multipass.
Join the Nation`s space program! The conference to get updates from the authors and core teams presenting on the West largest dome screen.
The Human 30%: Thriving as a Developer in the Age of AI Coding Assistants
Upcoming
The Human 30%: Thriving as a Developer in the Age of AI Coding Assistants
As AI coding assistants like Cursor, Jules, Cline and Copilot revolutionize software development, a new reality emerges: while these tools excel at generating boilerplate and routine functions-roughly 70% of coding work-they struggle with the crucial final 30% that transforms a basic solution into production-ready software. This talk explores how developers can adapt to this paradigm shift by strategically embracing AI for what it does best while doubling down on uniquely human skills. Drawing from industry leaders' insights, we'll examine why AI struggles with essential complexity like system architecture, edge cases, and maintainability, and how developers can position themselves as indispensable collaborators rather than competitors with AI. Whether you're a senior architect seeking to amplify your impact or a junior developer navigating this rapidly evolving landscape, you'll leave with practical strategies to elevate your craft beyond what AI can generate. Learn how to transform from code writers to systems thinkers, becoming "power users" who leverage AI as a force multiplier while maintaining ownership of the engineering decisions that matter most.
Never Worry About CORS Again With Bun’s Rendering API
Upcoming
Never Worry About CORS Again With Bun’s Rendering API
Fixing CORS errors is a frustrating rite of passage for every web developer. Bun's Rendering API makes it trivial to run your frontend and API on the same server, eliminating the entire category of cross-origin errors. Developers no longer need to wrestle with complex server-side headers or proxy requests just to fetch data from a different domain.
Build a MCP (Model Context Protocol) in Node.js
Nov 13, 15:00
Build a MCP (Model Context Protocol) in Node.js
Workshop
Julián Duque
Julián Duque
Model Context Protocol (MCP) introduces a structured approach to LLM context management that addresses limitations in traditional prompting methods. In this workshop, you'll learn about the Model Context Protocol, its architecture, and how to build and use and MCP with Node.jsTable of Contents:What Is the Model Context Protocol?Types of MCPs (Stdio, SSE, HTTP Streaming)Understanding Tools, Resources, and PromptsBuilding an MCP with the Official TypeScript SDK in Node.jsDeploying the MCP to the Cloud (Heroku)Integrating the MCP with Your Favorite AI Tool (Claude Desktop, Cursor, Windsurf, VS Code Copilot)Security Considerations and Best Practices
Register
Unpacking Bundling
Upcoming
Unpacking Bundling
JavaScript represents a big part of page weight - and optimising for performance often requires trimming or optimising the bundle - albeit imperfectly. At the same time, bundlers have never been more important in full-stack JS frameworks. In this session we’ll be rethinking how bundlers can optimise JS, if we let go of some of our previous assumptions about what bundling means.
Weaponizing LLMs to Hack JavaScript AI Applications
Upcoming
Weaponizing LLMs to Hack JavaScript AI Applications
Developers have gone full-steam from traditional programming to AI code assistants and vibe coding but where does that leave application security? What are the risks of LLMs introducing insecure code and AI applications manipulated through prompt engineering to bypass security controls?In a series of real-world application hacking demos I’ll demonstrate how developers mistakenly trust LLMs in generative AI code assistants that introduce insecure code and result in vulnerable applications that attackers easily exploit against you. We don’t stop here. We’ll apply adversarial attacks on neural networks in the form of prompt injection payloads to compromise LLMs integrated into AI application workflows and weaponize them for SQL injection and other business logic bypass.Join me in this session where you’ll learn how security vulnerabilities such as path traversal, prototype pollution, sql injection and other AI security risks are impacting LLMs and how to leverage AI security guardrails to secure GenAI code.
Entropy Tolerance: The Most Important Software Question You Aren't Asking
Upcoming
Entropy Tolerance: The Most Important Software Question You Aren't Asking
"Entropy Tolerance" is an original idea to help technical leaders navigate AI adoption decisions. This concept measures how much AI-generated uncertainty your systems and processes can handle before they break. Learn this decision-making framework to guide your teams on when to embrace AI and when to proceed with caution.
Shaping Framework Futures With Modern Tooling
Upcoming
Shaping Framework Futures With Modern Tooling
Frontend frameworks are increasingly converging, not just in features like Signals or first class TypeScript support, but also in shared tooling. Vite now powers most ecosystems, and meta-frameworks increasingly rely on Nitro and other unified layers.In this talk, we’ll look at the next phase of this convergence: the rise of Rust-powered tooling that will improve our workflows. Up first is Rolldown, a next-gen bundler offering not only speed or compatibility with Rollup, but also advanced optimization features like granular chunk control. Another tool, actually a set of tools that is part of the equation is Oxc, the Oxidation Compiler, a modular toolchain for parsing, transforming, minifying, but also linting and formatting JavaScript - at scale.You’ll leave with a clearer picture of where frontend tooling is heading and how you can adopt these tools today to benefit of the out-of-the-box performance and advanced features.
Prototyping Full-Stack Apps With Cursor
Upcoming
Prototyping Full-Stack Apps With Cursor
Workshop
Mike Mikula
Mike Mikula
In this workshop I'll cover fundamentals and a repeatable process on how to spin up full stack apps in Cursor. Expect to understand techniques such as using generative AI to create product requirements, database schemas, file trees, roadmaps etc. This will be used to generate checklists with memories to guide the entire application development process. We will dive further in on how to fix hallucinations/ errors that occur, useful prompts to make your app look and feel modern, approaches to get every layer wired up and more! By the end expect to be able to run your own AI generated full stack app on your machine!
Register
Building Durable Workflows From Scratch in JavaScript
Upcoming
Building Durable Workflows From Scratch in JavaScript
Durable workflows - workflows that checkpoint their state to automatically recover from failure - enable developers to build reliable code faster and dramatically reduce the severity of production incidents. Most workflow systems require you to set up a bunch of infrastructure, but that’s not necessary! In this talk, we’ll show you how to build durable workflows in pure JavaScript, as a library any application can import.
Modern React Architecture
Nov 11, 15:00
Modern React Architecture
WorkshopPro
Brad Westfall
Brad Westfall
In this workshop we'll dive into the latest advancements in React and best practices for building modern React apps. We'll take a look at modern NextJS and React Router 7 Framework (aka Remix) along with React's new "React Server Components". We'll also talk about improving the data-fetching strategies of your SPAs along with options for migrating your SPA to modern React Router.
Register
Lessons from Building Enterprise Remote MCP Server?
Upcoming
Lessons from Building Enterprise Remote MCP Server?
This talk shares real-world lessons from building and operating remote MCP (Model Context Protocol) server. It covers the architectural decisions, technical challenges, and practical insights that came from enabling scalable, context-aware model execution in one of the world’s largest payment platforms.
Building Desktop Apps Out of Web Apps: Scaling Electron With Code Signing & CI/CD
Upcoming
Building Desktop Apps Out of Web Apps: Scaling Electron With Code Signing & CI/CD
Electron bridges the web and desktop apps, enabling developers to turn web apps into cross-platform desktop experiences. But beyond the quick start lies a series of engineering challenges, from code signing headaches to CI/CD bottlenecks, and security risks.
One Config File To Rule Them All
Upcoming
One Config File To Rule Them All
Node.js introduces – experimental-config-file, a new experimental flag that enables loading a node.config.json file at startup. While it adds yet another config file, this powerful addition finally allows developers to customize Node.js execution in ways that were previously impossible. This talk explores the capabilities unlocked by this feature, including fine-tuned runtime behavior, improved portability, and potential future extensions.
DevTool Wars: Across the Browser-verse
Upcoming
DevTool Wars: Across the Browser-verse
Most developers use Chrome DevTools, but what about Firefox, Safari, and Edge? Venture off the well-traveled path, and we’ll find each browser hiding its own set of overlooked tools. We’ll explore how they uniquely tackle accessibility, design, debugging, and more. Let’s follow the firefox, dive beneath the chrome on a cross-browser safari, and discover where each dev tool has the edge!
Pragmatic 101 on Custom JS Tooling for Your Project
Nov 11, 15:00
Pragmatic 101 on Custom JS Tooling for Your Project
Workshop
Will Klein
Will Klein
Let’s demystify the secrets of modern JavaScript tooling. In this workshop, you will learn how linters, compilers, and code transforms work. You will take your first steps building your own developer tools, writing an ESLint rule, a compiler plugin, and a code transformation. Learn these skills to help your team and deepen your understanding of computer languages.Workshop Plan:A preview of how ASTs can be usedA brief walkthrough of how compilers workAn intro to working with an ASTThe secret to making thousands of changes in secondsHow to apply this skill
Register
The 2025 State of JavaScript Testing
Upcoming
The 2025 State of JavaScript Testing
Have we been stuck in the same testing pain loops for years? Even though it might seem like it, we haven't!Even if AI is now writing our tests, many JavaScript developers have faced numerous challenges, from the unclarity of test classifications to the struggle of mocking, long-running integration tests, and shifting everything to E2E tests.Let's recap everything that has happened in the past years and look into the present to explore what 2025 will bring for testing in the JavaScript world around test runners, testing libraries, mocking, production practices, and AI-based tools.
Let's Build Your Personal AI Agent in JavaScript
Upcoming
Let's Build Your Personal AI Agent in JavaScript
We all have those repetitive web tasks we wish would just handle themselves – sorting through data, extracting information from multiple pages, or customizing content for different audiences. What if your JavaScript application could do this autonomously, right in the browser?This talk demonstrates how to create intelligent AI agents in JavaScript that eliminate tedious tasks without sending sensitive data to the cloud. We'll combine modern web technologies with client-side AI techniques like RAG (Retrieval-Augmented Generation) and function calling to build applications that understand content, make decisions, and take actions based on user goals.
TypeScript on the GPU – Bridging the Gap Between Realms
Upcoming
TypeScript on the GPU – Bridging the Gap Between Realms
Join me for a technical deep-dive on TypeGPU which, among other things, allows your WebGPU shader to be made up of JavaScript either partially or entirely. This means a library can be written fully in WebGPU Shading Language, yet accept a JS callback that gets compiled and injected into the shader code. Improving APIs by going past just tweaking knobs and parameters.In my talk, I’ll be touching upon how we offload most of this work to a build-step while still supporting dynamic scenarios, how we mitigate the differences between JavaScript and WebGPU Shading Language, and how we leverage existing tooling like the TypeScript language server to make CPU and GPU code connect seamlessly through types.
They Said JavaScript Couldn't Make Beautiful Art – They Were Wrong
Upcoming
They Said JavaScript Couldn't Make Beautiful Art – They Were Wrong
Discover how JavaScript and canvas sketch transform mundane code into mesmerizing visual art in this eye-opening session. This talk reveals practical techniques to generate algorithmic masterpieces using simple math principles, demonstrates live coding examples that blur the line between development and artistry, and shares how this creative coding approach revolutionized my own work. Whether you're a seasoned developer or creative coder, you'll walk away with the skills to express your artistic vision through code and join the growing community of computational artists pushing the boundaries of digital creation.
Diving Into the Toplayer: Where Dialogs, Popovers, and Modals Live
Upcoming
Diving Into the Toplayer: Where Dialogs, Popovers, and Modals Live
The web platform is evolving, introducing powerful new primitives that change how we build interfaces. Among these innovations is the toplayer – an important yet often misunderstood rendering concept. This talk explores the toplayer rendering mechanism, learning how it enables UI patterns and examining its role in accessibility, performance, and developer experience.The toplayer isn't just another technical specification—it represents a shift in how browsers handle elements that need to break out of the normal document flow. From dialog elements to the new popover API, custom tooltips to modal interfaces, the toplayer has quietly become essential for creating modern web experiences. By understanding how the toplayer works, developers can build more robust, accessible, and maintainable components while avoiding common pitfalls that lead to inconsistent user experiences.In this session, we'll dive into the toplayer to understand how browsers handle stacking contexts, painting order, and focus management within the toplayer. Through practical examples and live coding demonstrations, attendees will gain both theoretical understanding and practical skills they can apply to their own projects.
TanStack Router: Beyond the Basics
Upcoming
TanStack Router: Beyond the Basics
Modern routing isn’t just about navigating between pages anymore - it’s about dynamic data loading, route transitions, and user experience. Join us as we uncover the superpowers of TanStack React Router. We’ll explore features that go beyond the basics, like nested routing, type-safe loaders, and prefetching strategies. Expect a fun ride with real-world examples, tips to optimize performance, and a live demo of building a mini-dashboard app that uses all the best features of TanStack Router.
From Fragile to Future-Proof: Solving Web Monetization Chaos with Payment Systems That Scale
Upcoming
From Fragile to Future-Proof: Solving Web Monetization Chaos with Payment Systems That Scale
What happens when 'just integrate Stripe/Adyen/Revolut' isn't enough? As platforms grow, payments turn from a simple integration into a complex web of gateways, compliance, and strategy conflicts. This talk is for anyone who's hit scaling pain. I'll walk through the hard lessons from moving millions through fragmented systems, and show how treating payments as orchestration, not a feature, can unlock real growth. No fluff, just the realities of building monetization systems that scale.
What Happens When an AI Has Access to a Node.js Environment? Spoiler: Wild Things
Upcoming
What Happens When an AI Has Access to a Node.js Environment? Spoiler: Wild Things
Give an AI access to a real Node.js runtime, and things start to get interesting. It can run code, install packages, generate files, and even launch servers on the fly. In this talk, you will see how I built a Node.js Sandbox server powered by the Model Context Protocol (MCP), an open standard that connects AI to real tools and data in a safe, controlled way.We will walk through how the sandbox works: starting fresh Docker containers, installing npm packages on the fly, executing JavaScript, and sending back logs or files. Everything happens through simple MCP messages, allowing the AI to interact with your system just like a developer would, only faster.You will see how this unlocks powerful use cases like generating charts with Chart.js, summarizing long articles from the web, creating and testing QR codes, scraping and saving content, generating PDFs and fake CSV data, or even spinning up mock APIs in seconds. By the end, you will know how to build your own MCP server and give your AI the keys to a real coding playground.
JavaScript File Handling Like a Pro: From ZIP Streams to Memory-Efficient Parsing
Upcoming
JavaScript File Handling Like a Pro: From ZIP Streams to Memory-Efficient Parsing
Handling files in JavaScript goes far beyond fs.readFile. In this practical talk, you'll learn how to process large files efficiently using streams, pipeline(), async iterators, and backpressure handling — all without crashing your server. From real-time CSV parsing to ZIP decompression and production-safe file cleanup, we’ll explore powerful patterns that make your Node.js apps faster, safer, and ready for scale.
What Data Analysts Wish JavaScript Developers Knew: Lessons from Healthcare Finance
Upcoming
What Data Analysts Wish JavaScript Developers Knew: Lessons from Healthcare Finance
Behind every healthcare dashboard or billing report is a complex web of data logic, regulatory standards, and human decisions. As a Senior Analyst working at the intersection of medical finance and technology, I’ve spent years navigating payment audits, EHR systems like EPIC, and revenue optimization — all using SQL, Python, and data visualization platforms like Tableau.But too often, the tools we rely on break down at the interface level. Whether it’s a dashboard that hides critical edge cases, a confusing filter logic, or performance bottlenecks with large datasets, the gap between engineers and analysts becomes painfully clear.In this talk, I’ll share what non-JavaScript professionals (like data analysts and healthcare teams) wish JS developers understood — from the importance of transparent data flows and smart defaults, to accessibility for non-technical users and the challenges of real-world billing logic.This isn’t a technical deep dive into code — it’s a real-world case study of how design decisions in JS-powered tools can make or break healthcare outcomes, and how engineers can build better, more empathetic data tools.
Local First – Collaboration Beyond Cloud
Upcoming
Local First – Collaboration Beyond Cloud
For years, we’ve defaulted to centralised servers and, more recently, leaned heavily on server-side components to power our web apps. But this dependence has a cost: apps that break without constant internet connectivity, sluggish performance under heavy load, and user frustration when things don’t just work.

This talk challenges the cloud-first status quo and invites developers to explore the power of **local-first**. Imagine building multiplayer, collaborative experiences that thrive offline, sync smoothly when online, and harness the value of localised state. We’ll also tackle the complexities of conflict resolution when shifting from a centralised authority to a sync server as a lightweight mediator. It’s time to rethink collaboration.
Eye Tracking & a11y on the Edge: Build an Eye Tracking With AI Running on Your Device!
Upcoming
Eye Tracking & a11y on the Edge: Build an Eye Tracking With AI Running on Your Device!
Today it's possible to create advanced eye tracking systems without specialized hardware but simply using a standard webcam and the inevitable AI. But the real difference is made by the model that is already completely on the edge and therefore on the device or browser, allowing you to work even offline!

With 'AI on the edge' technologies for facial and eye detection, a bit of linear regression, and a real-time calibration system that adapts to the user and environment, I will show, using only JavaScript and on-device AI models,  the results of the experiment, discussing accuracy, current limitations, and potential improvements.

The challenges faced in on-device optimization are many to balance precision and performance, but this experiment opens new possibilities for accessible applications in human-machine interaction, behavioral studies, and accessibility systems, all created with open source technologies and common hardware!
Meta Framework for Kubernetes: TypeScript Meets Cluster Control
Upcoming
Meta Framework for Kubernetes: TypeScript Meets Cluster Control
Kubernetes doesn’t have to be hard. In this talk, we’ll explore kubernetes-fluent-client, a TypeScript-based meta framework that makes working with the Kubernetes API intuitive even if you’ve never touched client-go. From building controllers to managing subresources like logs, scale, and proxy, this talk dives into how the fluent client simplifies cluster interaction through a clear, expressive API, server-side apply, and custom informers. Whether you’re writing automation or full-blown operators, you’ll walk away ready to build Kubernetes-native applications faster and with less boilerplate. KFC is the Kubernetes Client that serves as the engine for Pepr (An Admission Controller and Operator Framework built in TypeScript) and is an npm package.
Demystifying npm: What Actually Happens When You Install and Publish
Upcoming
Demystifying npm: What Actually Happens When You Install and Publish
npm powers the JavaScript ecosystem, but many developers still treat it as a black box.This talk aims to demystify core npm workflows and give developers with various levels of experience a clearer mental model of how npm works behind the scenes. With the rise of AI-assisted coding, many engineers are shipping code that depends on npm without deeply understanding it. Meanwhile, seasoned developers often struggle with subtleties around publishing, dependency resolution, and security.This talk clarifies the install and publish lifecycle, surfaces modern best practices, and offers decision-making tools that help developers avoid surprises and regain control over their tooling.
Interactive Debugging and Control in Node.js With REPL
Nov 19, 15:00
Interactive Debugging and Control in Node.js With REPL
Workshop
Edy Silva
Edy Silva
You probably have faced a situation where you needed to debug something particular in your application. Something in a specific condition. These kinds of situations tend to be poorly handled by us developers.A common approach is adding a bunch of logs, deploying the code, and waiting for the logs to return. This is a very slow process and can be very frustrating.It would be much better if you could just get into the environment, while running, execute some code, and see the results. This is where the node:repl module comes in. It allows you to create a Read-Eval-Print Loop (REPL) in your Node.js application.Inspired by Ruby on Rails, which has a very useful console, I implemented a console in the application I was working on. It was a game changer. Now, we have a way more effective debugging/experimentation process. My team fell in love with it. Now, it's part of the app, as it always has been.Another good thing is that it was not hard to implement. The node:repl module gives everything. We just need to ensure the application is properly bootstrapped to use the REPL module.Table of contentsThe importance of tools and DXThe module node:replHands-on: creating an iterative repl for debugging any applicationConclusionTakeawaysWhy DX matters and how to improve it through the development of custom toolsHow Node.js modules can help with the creation of effective toolsGet to know the node:repl module
Register
When the Safety Net Catches Fire: Solving Feature Flag Problems at Scale
Upcoming
When the Safety Net Catches Fire: Solving Feature Flag Problems at Scale
Feature flags seem simple enough: an on/off switch in your code. But as your team grows, the code gets more complex, and you add more flags, things can quickly go off the rails. Soon enough, you're wondering if a flag is safe to delete, why a toggle no longer in use is still slowing down your app, and why your React components flicker on every page load. This talk covers the three biggest problems I see JavaScript teams hit when scaling feature flags - and the patterns that actually work.
Generative Engine Optimization: How to Build AI-Discoverable Websites
Upcoming
Generative Engine Optimization: How to Build AI-Discoverable Websites
Search is evolving. As AI tools like Perplexity, ChatGPT, and Google SGE transform how users discover content, traditional SEO strategies fall short. Today’s web visibility depends on how well your site communicates with machines, not just humans.In this talk, we’ll explore the foundations of Generative Engine Optimization (GEO)—a new approach to building websites that surface in AI-driven search results. You’ll learn how to structure content for LLMs, create AI-friendly endpoints, and evaluate how your site appears through the lens of generative systems.We'll also walk through a live demo to show these techniques in action, with patterns you can apply regardless of your framework.
Beyond JavaScript: Unleashing the Power of WebAssembly for Faster Web Apps
Upcoming
Beyond JavaScript: Unleashing the Power of WebAssembly for Faster Web Apps
JavaScript is great, but it wasn’t built for high-performance tasks like complex data processing or 3D rendering. That’s where WebAssembly (WASM) comes in — a technology that can deliver near-native performance directly in the browser. In this talk, I'll show you how WASM can supercharge your web apps with a real-world demo, where it dramatically outperforms JavaScript in sorting a large dataset. You'll also discover how industry leaders like Prime Video and Figma leverage WASM for massive performance gains. This session will equip you with practical insights and best practices to integrate WASM into your own projects.
Beyond Code: Crafting Effective Discussions to Further Technical Decision-Making
Upcoming
Beyond Code: Crafting Effective Discussions to Further Technical Decision-Making
Whiteboards. Proof of Concepts. Pairing. Spikes. These are all tools we use every day to have high-level technical conversations about ideas we propose or approaches we think are the “right” way. As someone advances in their career into more experienced levels of software engineering, however, a critical skill becomes how you conduct and lead these conversations. It involves clearly articulating a vision and securing buy-in, while also valuing and integrating the diverse perspectives and feedback from your peers. The goal beyond each individual conversation is to foster an environment where ideas can be exchanged, discussed, enhanced, and decided on. You’ll walk away from this talk with some new, innovative approaches to try out that not only help get your technical ideas across but also solicit additional thoughts and opinions in ways that engage and effectively address different points of view.