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

  Neha  Seth

Varun

Lera

Daria Shabala

Richard Carrigan

Brian Whippo

Pascal Moser

Mauro Bartolomeoli

Herrington Darkholme

David Mytton

Trust Jamin

Maya Shavin

Hunor Márton Borbély

Dipanshu Gupta

Seungho Park

David Pugh

Shylesh B C

Alla Kaplia

Oscar Pagani

Jennifer

Bernie Green

Rocío

Bruno da Hora

Ian Sutherland

Bob Fornal

Diogo Pedro

Denis Radin

Petro Orel

Nick M

Natalia Sabadysh

Suzy Nakayama

khouchane Mahmoud

Jim Hoffman

The role of the software engineer is undergoing a fundamental shift. As AI becomes deeply integrated into our workflows, a new paradigm is emerging: the AI-Native Software Engineer. This isn't about being replaced; it's about amplification. This talk presents a practical playbook for developers to transition to AI being a versatile partner across the entire software development lifecycle.We'll explore the crucial mindset shift required to see AI as a productivity multiplier, not a threat. You will learn how to effectively orchestrate AI agents and tools - including the new Chrome DevTools MCP - to delegate routine tasks and free yourself to focus on high-level problem-solving, architecture, and innovation. We will move beyond basic code generation and discuss applying AI to system design, testing, debugging, and operations, transforming your role from a code writer to a systems thinker. Join me to discover how to "trust, but verify," maintain ultimate ownership and quality, and become an indispensable AI-native engineer who is shaping the future of software.

The AI-Native Software Engineer

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

Jarred Sumner

Things are evolving constantly and it's hard to know what's worth your time. As someone who learns and teaches for a living, Scott explores the web platform and what really matters.

Keeping Up with The Fast and Furious Web

Scott Tolinski 

Signals and fine-grained reactivity have recently become staples in modern JavaScript frameworks. However, 9 years ago, when Ryan Carniato created SolidJS, the blueprint for the modern framework, that was not the case at all. Today more developers use Signals than ever before, but we are only at the beginning of the journey. Join Ryan as he looks to the future of fine-grained reactivity, web development, and explores what lies beyond Signals.

Beyond Signals: The Next Big Shift in Web Reactivity

Ryan Carniato

Node.js continues to thrive despite claims of its decline. We'll debunk myths, highlight recent enhancements, and demonstrate its robust performance in today's tech landscape. The talk will cover Node.js's role in server-side programming and cloud-native applications, community contributions, integration of modern JavaScript features, and influence of emerging technologies. We'll conclude by projecting Node.js's bright future and growth areas in the evolving tech world.

The State of Node.js 2025

Matteo Collina

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.

Rethinking Bundling: Why You Don’t Need Less JavaScript

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.

The End of Frontend Fragmentation? How Rust is Unifying Frameworks & Tooling

Alexander Lichter

Modern apps face significant security threats, especially for browser-based JavaScript apps. This short talk will help you understand how app architecture and auth security impact each other. You will learn the most secure, standards-based architecture pattern for implementing auth for JS apps.

Backend-for-Frontend Auth: The Secure JS App Architecture

Kim Maida

AI coding assistants are great at completing small tasks or features. However, what do you do when you are working with more complex code bases, and you need to build in-depth features that need upfront planning?This talk explores spec-driven development as a solution to this problem. I'll show you how modern AI coding assistants (like Kiro) can help break down complex tasks into three distinct phases. We'll look at the real-world tradeoffs of this approach, and most importantly and how you can use it in your own projects right away.

Using Spec-Driven Development for Production Workflows

Erik Hanchett

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

Setting up our beloved devtools with the right performance testing setup! Are you navigating through your performance panel right? Are you leveraging all the amazing performance features from the devtools? Got the right browser extensions installed?

Get Set Up for Performance Testing With DevTools

Nishu Goel

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

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

Will Klein

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

Imagine the convenience of executing TypeScript files directly with Node.js using `node file.ts`. Just a few years ago, this concept seemed like a distant dream. Today, it stands as an exciting experimental feature. This narrative dives into the journey of transforming this dream into a reality. Integrating TypeScript natively into Node.js posed significant challenges. These hurdles included managing TypeScript’s lack of strict semantic versioning guarantees and accommodating various TS flavors. Today, the experimental native TypeScript support in Node.js marks a transformative milestone. Beyond merely executing .ts files, it signifies a leap forward in JavaScript development.

Node.js + TypeScript: A Native Integration Years in the Making

Marco Ippolito

Get ready for a fresh spin on frontend creativity! In this session, Elian will introduce some cutting-edge web APIs and showcase live demos that push the boundaries of what’s possible in the browser. From playful, interactive experiments to genuinely useful features you can use today, join us for a hands-on journey and get inspired to make the web a little weirder (and a lot more fun).

Beyond Boring: Unlocking the Web’s Wild Side

Elian Van Cutsem

You'll learn how to move beyond basic prompting to create comprehensive workflows to give your AI coding assistants all the architecture, best practices, project rules, code examples, and validation processes it needs to get the job done effectively. Through hands-on exercises with Claude Code, we'll demonstrate how proper Context Engineering unlocks a whole new level of agentic engineering while teaching practical techniques, templates, and best practices that help AI assistants understand your project standards and deliver production-ready code consistently.

Advanced Claude Code Techniques: Agentic Engineering With Context Driven Development

Cole Medin

Still wondering what blockchain is actually good for? This talk breaks it down in clear, developer-friendly terms: what makes it different and where it's useful. You'll explore real-world examples and see how AlgoKit 3.0 adds a powerful new tool to your stack — enabling you to build full decentralized applications, including smart contracts, using one familiar language: TypeScript.

A JS Dev's Guide to Not Dismissing Blockchain

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

Compilers have long been seen as one of the most complex topics in computer science. Nowadays, web frameworks are evolving from runtime libraries into optimizing compilers and reshaping how we build user interfaces. Different topics in front-end development—e.g., reactive programming—are now experiencing this era fueled by static-analysis-driven insights.This talk will explore how modern UI compilers are redefining performance and developer experience. We’ll discuss how some compilers are designed and different open-source solutions — including the React Compiler, Million.js, Svelte, and Marko, as well as enterprise apps, and the growing role of compilers in automating things.By the end of the session, you'll probably be optimistic about a future where compilers understand our entire code and offload a huge part of our mental burden related to manual tasks!

Compilers, User Interfaces & the Rest of Us

Matheus Albuquerque

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

Enterprise AI is an orchestration problem. We need systems that are modular, observable, and scalable – from our central data centers to the edge. This session is an architectural tour of how LangGraph.js provides the “glue” to connect these modern enterprise patterns in a TypeScript/Node.js environment.We’ll start by framing the AI agent as a “Modular Monolith”—a single, deployable service built from testable, graph-based components. This explicit graph structure isn’t just for logic; it makes Observability a First-Class Citizen, allowing us to trace the agent’s cyclical reasoning in production.Next, we’ll deploy this agent as an intelligent Backend-for-Frontend (BFF), empowering our full-stack applications with stateful orchestration. Finally, we’ll tackle the next frontier: Architecting for the Edge. We will explore patterns for managing persistent agent state in a hybrid environment, allowing our AI to run anywhere.This talk is for the architect and engineer who needs to build and scale real-world, enterprise-grade AI applications.

Full-Stack AI Orchestration: Modular Agents, Observability, and the Edge

Jamal Sinclair O'Garro

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

Design-to-code moves faster when your agent has the right context at each step. I’ll show how the Model Context Protocol (MCP) lets you stitch together servers so the agent can pull structured design signals from Figma – variables, components, design notes, and Code Connect mappings – and pair them with your editor/project rules to make grounded implementation choices. From there, adding a few more servers for documentation, runtime checks in a real browser, and version control gives the agent richer, verifiable inputs instead of guesswork. The payoff: fewer “rogue” detours because decisions are anchored to real sources and less context-switching since developers stay in the IDE while the agent gathers what it needs. It’s a practical path from design intent to production-ready changes – powered by composable context rather than one-off integrations.

Fast Track Design to Code With Figma MCP

Riccardo Erra

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

Discover Firebase Studio, Google's new AI-powered, cloud-based workspace designed to supercharge your JavaScript development. Integrating a CodeOSS IDE, Gemini AI assistance, and Firebase JS SDK, Studio streamlines building, testing, and deploying full-stack JavaScript apps. Learn how Studio's AI accelerates coding, how templates get you started faster, and how to securely infuse your apps with the Gemini API using the production-ready Vertex AI in Firebase SDK. Key Takeaways: Leverage Firebase Studio for JavaScript; Boost productivity with AI assistance; Integrate Gemini securely via Vertex AI; Streamline your workflow from idea to deployment.

AI-powered JavaScript Development

James O'Reilly

Alex Astrum

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

The great thing about your dusty old project from when you were starting out in starry-eyed is that for better or worse that old code contained a set of rules, logic and system design that can form the backbone of a robust spec. In this talk, you'll learn how to translate your old projects into detailed specs that combined with agentic spec-driven development can give those projects new life and a new audience.

Giving Old Projects New Life With Spec Driven Development

Leon Malisov

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 

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

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

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

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

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

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

Learn how to build applications that are inclusive, scalable, and ready for real-world users. Karly Lamm shares practical strategies for making accessibility a natural part of your JavaScript development process, helping you create better experiences for everyone.

Accessible by Default: Building Apps That Everyone Can Use

Karly Lamm

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

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

In this workshop, I’ll guide participants through a process for building full-stack applications using Cursor. We’ll cover setting up Cursor workflows, including rules, commands, and custom modes, to streamline development. We will use Cursor to draft PRDs, database schema, etc and a simple SOW. We’ll turn notes into actionable checklists to guide the build, connecting the front end, API, and database.Additionally, we’ll create workflows for debugging, testing, reviewing, and fixing the app while reducing hallucinations with precise prompts. The session will also include a security review workflow and techniques for applying prompts to achieve a modern UI design. Attendees will leave with a functioning app on their machine and a reusable development process.

How to Build Full-Stack Apps Using Cursor

 Shrey Shah

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 the main #JavaScript conference in the US. Join me and 10k other JS engineers. Follow this link to receive a free remote ticket. The theme of the year is AI for coding and the future of #WebDev.

#JSNation

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

CKEditor

Hygraph

Bloomberg

Knock

FusionAuth

CodeRabbit

Typesense​

Algorand

ButterCMS

Firebase

Arcjet

Zencoder

AWS (Kiro)

CKEditor is a modern, feature-rich JavaScript text editor with clean UI and perfect UX

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.

JSNation US 2025

See JS stars in the US biggest planetarium

Neha Seth

Varun

Lera

Daria Shabala

Richard Carrigan

Brian Whippo

Pascal Moser

Mauro Bartolomeoli

Herrington Darkholme

David Mytton

Trust Jamin

Maya Shavin

Hunor Márton Borbély

Dipanshu Gupta

Seungho Park

Lera

David Pugh

Shylesh B C

Alla Kaplia

Oscar Pagani

Jennifer

Bernie Green

Rocío

Bruno da Hora

Ian Sutherland

Bob Fornal

Diogo Pedro

Denis Radin

Petro Orel

Nick M

Natalia Sabadysh

Suzy Nakayama

khouchane Mahmoud

Jim Hoffman

Total attendees