Name: JSNation US 2025
Start: 2025-11-17T13:00:00.000Z
End: 2025-11-20T22:59:00.000Z

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.

The Human 30%: Thriving as a Developer in the Age of AI Coding Assistants

Addy Osmani

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.

Never Worry About CORS Again With Bun’s Rendering API

Jarred Sumner

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:<ul><li>What Is the Model Context Protocol?</li><li>Types of MCPs (Stdio, SSE, HTTP Streaming)</li><li>Understanding Tools, Resources, and Prompts</li><li>Building an MCP with the Official TypeScript SDK in Node.js</li><li>Deploying the MCP to the Cloud (Heroku)</li><li>Integrating the MCP with Your Favorite AI Tool (Claude Desktop, Cursor, Windsurf, VS Code Copilot)</li><li>Security Considerations and Best Practices</li></ul>

Build a MCP (Model Context Protocol) in Node.js

Julián Duque

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.

Unpacking Bundling

Daniel Roe

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.

Weaponizing LLMs to Hack JavaScript AI Applications

Liran Tal

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

Entropy Tolerance: The Most Important Software Question You Aren't Asking

Tony Alicea

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.

Shaping Framework Futures With Modern Tooling

Alexander Lichter

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!

Prototyping Full-Stack Apps With Cursor

Mike Mikula

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.

Building Durable Workflows From Scratch in JavaScript

Peter Kraft

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.

Modern React Architecture

Brad Westfall

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.

Lessons from Building Enterprise Remote MCP Server?

Hemanth HM

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.

Building Desktop Apps Out of Web Apps: Scaling Electron With Code Signing & CI/CD

Ayodele Aransiola

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.

One Config File To Rule Them All

Marco Ippolito

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!

DevTool Wars: Across the Browser-verse

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:<ol><li>A preview of how ASTs can be used</li><li>A brief walkthrough of how compilers work</li><li>An intro to working with an AST</li><li>The secret to making thousands of changes in seconds</li><li>How to apply this skill</li></ol>

Pragmatic 101 on Custom JS Tooling for Your Project

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.

The 2025 State of JavaScript Testing

Daniel Afonso

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.

Let's Build Your Personal AI Agent in JavaScript

Aileen Villanueva

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.

TypeScript on the GPU – Bridging the Gap Between Realms

Iwo Plaza

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.

They Said JavaScript Couldn't Make Beautiful Art – They Were Wrong

Raihan Nismara

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.

Diving Into the Toplayer: Where Dialogs, Popovers, and Modals Live

Tim Damen

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.

TanStack Router: Beyond the Basics

Joana Santos

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.

From Fragile to Future-Proof: Solving Web Monetization Chaos with Payment Systems That Scale

Faris Aziz

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.

What Happens When an AI Has Access to a Node.js Environment? Spoiler: Wild Things

Alfonso Graziano 

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.

JavaScript File Handling Like a Pro: From ZIP Streams to Memory-Efficient Parsing

Noam Zingboim

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.

What Data Analysts Wish JavaScript Developers Knew: Lessons from Healthcare Finance

Aikerim Belispayeva

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.

Local First – Collaboration Beyond Cloud

Kritiketan Sharma

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!

Eye Tracking & a11y on the Edge: Build an Eye Tracking With AI Running on Your Device!

Francesco Sciuti

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 <a href="https://github.com/defenseunicorns/pepr" target="_blank">Pepr</a> (An Admission Controller and Operator Framework built in TypeScript) and is an npm package.

Meta Framework for Kubernetes: TypeScript Meets Cluster Control

Casey Wylie

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.

Demystifying npm: What Actually Happens When You Install and Publish

Karen Li

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 contents<ul><li>The importance of tools and DX</li><li>The module node:repl</li><li>Hands-on: creating an iterative repl for debugging any application</li><li>Conclusion</li></ul>Takeaways<ul><li>Why DX matters and how to improve it through the development of custom tools</li><li>How Node.js modules can help with the creation of effective tools</li><li>Get to know the node:repl module</li></ul>

Interactive Debugging and Control in Node.js With REPL

Edy Silva

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.

Generative Engine Optimization: How to Build AI-Discoverable Websites

Simon Ouyang

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.

When the Safety Net Catches Fire: Solving Feature Flag Problems at Scale

Ryan Feigenbaum

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 JavaScript: Unleashing the Power of WebAssembly for Faster Web Apps

Nitin Gupta

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.

Beyond Code: Crafting Effective Discussions to Further Technical Decision-Making

Allison McMillan

Join the Nation`s space program! The conference to get updates from the authors and core teams presenting on the West largest dome screen.

JSNation US

I’m attending JSNation US. Join me there for free with 10k other JS engineers and 50+ great speakers. Just follow this badge.

Join the Nation`s space program! The conference to get updates from the authors and core teams presenting on the West largest dome screen.

JSNation US 2025

FocusReactive

Hygraph

Bloomberg

FusionAuth

Typesense​

Algorand

ButterCMS

With 10,000+ front-end apps + one of the world’s largest JavaScript/TypeScript codebases, @TechAtBloomberg is deeply committed to using JS/TS in building the world's most trusted information network for finance pros.

Any Language. Any Platform. Any Technology.

Algorand is an energy-efficient, quantum-secure, single-layer blockchain with instant finality, consistently high throughput, and low fees.

Typesense is an easier-to-use alternative to Elasticsearch, to help you build blazing-fast search experiences for your sites and apps.&nbsp;Yes, it has AI magic built-in as well (vector search, image search, voice search, etc).&nbsp;

JSNation US 2025

See JS stars in the US biggest planetarium