Name: Web Engineering Summit 2026
Start: 2026-06-11T07:00:00.000Z
End: 2026-06-15T18:00:00.000Z

Elian Van Cutsem

Seungho Park

Irina Baeva

Karthick Shanmugam

HT Sahin

David Pugh

Yomi Eluwande

João Cidade Silva

Ricardo Machado

Ayla-Brianna Waters

Brent Kearney

Montaga Pallarols

Cvetanka Nechevska

Boris Karaivanov

Vitor Barbosa

Oleksii

Sanketh Kumar

Lala Hakobyan

Pratik Ghosalkar

Aliaksandr Melnik

Arash Sarfehjou

Paolo Mauri

Mike De Petris

Tamara

Basseydou OUATTARA

Daniel Núñez

David Santiago Garcia Chicangana

FLOR URBINATI

Julián Parrilla Calvo

Oleh Vdovenko

Fathima Fasna

Muhammad Aqib Javaid

Nu Phan Quynh Do

In this workshop, we'll go beyond the fundamentals and explore some of the more powerful features React Query has to offer. You'll gain a deeper understanding of how it works under the hood and learn how to write scalable, maintainable React Query code.Together, we'll build a simple example app and incrementally enhance it with one core objective in mind: delivering the best possible user experience. That means snappy interactions, minimal layout shifts, and avoiding unnecessary loading spinners wherever we can.To achieve this, we'll dive into advanced techniques like various forms of prefetching (including integration with route loaders), seeding the query cache, crafting smooth paginated experiences, and even persisting query state through full page reloads using persistence plugins.Note: You should have prior knowledge about React Query if you attend this workshop.

React Query - Beyond the Basics

Dominik Dorfmeister

Ever wonder how much of your codebase is just… hanging around, doing nothing? At Sentry, we did too - and the answer was more than we expected. In this talk, I’ll share how we used Knip, a powerful tool for detecting unused files, exports, and dependencies, to declutter our frontend codebase. You’ll learn about the practical steps we took to safely identify and remove dead code, how we integrated Knip into our workflows, about unexpected edge-cases and what we learned along the way. Whether you're maintaining a massive monolith or just looking to tidy up, this session will give you practical strategies - and maybe a little inspiration - to start decluttering your own codebase, one Knip at a time.

Dead Code Shouldn’t Exist: How We Removed 28k Lines of Code, One Knip at a Time

At tldraw, we've been exploring the infinite canvas as a surface for real-time collaboration between multiple agents and multiple users. Learn about what works, what doesn't, and whether the future AI might live on the canvas.Our work with AI on the canvas began with makereal.tldraw.com, often cited as the first "vibe coding" tool to reach escape velocity in November 2023. We later did work with realtime drawing (drawfast.tldraw.com), autocomplete, and a canvas interface for AI with (teach.tldraw.com). In 2024, we shipped an AI workflows app (tldraw.computer) and then returned to our canvas AI learnings with a public starter kit for working on the canvas with cursor-style AI agents (https://tldraw.dev/starter-kits/agent) and then later our spatialized agents-on-the-canvas experiment (fairies.tldraw.com).

Agents on the Canvas With tldraw

Max Drake

What happens when you turn your audience into a live, distributed load test?We will kick off this session with a high-stakes, multiplayer "Whack-a-Mole" challenge played right from your phone. As you compete for the leaderboard, a live stream of concurrent data will be generated to showcase realtime web capabilities in action across devices.After playing around, it is time to get serious by digging into the challenges, architecture and technologies used when building such a platform. Discover how helpful or distracting AI can be during this process.Key takeaways include:<ul><li>AI: The Good &amp; The Glitchy!</li><li>The Stack: NextJS, Supabase.</li><li>Realtime: No longer refreshing the page.</li></ul>Leave the theory behind and see how modern tools and a bit of trial and error handle the chaos of live user interaction.

Stress Test Your Reflexes (And My App) 

Eddie Jaoude

Ready to go from zero to deployed voice agent?Voice AI is moving fast, but most tutorials end at "hello world" and leave you wondering how to actually ship something to production. This intensive workshop takes you through the entire journey: building a complete voice agent with TypeScript and React, deploying it to production, setting up observability, and creating evaluation frameworks—all the pieces you need for real-world JavaScript applications.What you'll build:<ul><li>A full-stack voice agent using LiveKit's TypeScript SDK</li><li>React UI with real-time audio visualization and state management</li><li>Production deployment with proper observability</li><li>Automated testing and evaluation frameworks</li></ul>Topics covered:<ul><li>Setting up WebRTC audio streams with TypeScript</li><li>Integrating STT, LLM, and TTS models in your JavaScript stack</li><li>Building React UI for voice interactions with real-time state</li><li>Handling interruptions and natural turn-taking</li><li>Deploying to production (Vercel)</li><li>Setting up observability and session replay</li><li>Building evaluation frameworks for quality assurance</li></ul>This isn't a demo – it's a bootcamp. You'll write TypeScript code, debug issues, and deploy to production. By the end, you'll have a working voice agent and the confidence to build more.

Voice Agent Bootcamp: Build Production-Ready Agents from Scratch

Jesse Hall

<div><span style="box-sizing:border-box;margin:0px;padding:0px;font-style:inherit;font-variant:inherit;font-weight:inherit;font-stretch:inherit;line-height:inherit;font-family:inherit;font-optical-sizing:inherit;font-size-adjust:inherit;font-kerning:inherit;font-feature-settings:inherit;font-variation-settings:inherit;font-language-override:inherit;font-size:16px;vertical-align:baseline;border:0px">Many front-end developers build modern applications with confidence, but struggle when it comes to shipping those applications to production. Docker, CI/CD, environment configuration, performance tuning, and deployment often remain “someone else’s job” — until something breaks and becomes your responsibility. This workshop closes that gap. It’s a practical, production-focused workshop designed for front-end developers who want to take full ownership of their front-end applications — from local development to stable, production-ready deployments. You’ll learn how to: </div><ul><li>Dockerize front-end applications for both development and production</li><li>Create optimized, production-ready Docker images for modern front-end frameworks</li><li>Optimize front-end applications for performance, stability, and reliability</li><li>Avoid common production mistakes seen in real-world front-end projects</li></ul>Docker for Front-end Developers is a practical book designed specifically for front-end engineers who want to truly understand and confidently use Docker in real-world projects — written by Docker Captain and author of the official Docker React.js sample documentation Kristiyan Velkov — with 30% off using code DOCKER30.

DevOps for Front-end Developers: From Local Code to Production by Docker Captain

Kristiyan Velkov

Direct the code. Don't just write it.The development landscape is shifting from manual coding to system orchestration. Whether you are a seasoned React engineer looking to 10x your output or a product-driven creator aiming to turn a prototype into a functional app, this workshop is your gateway to AI-native development.Join us for a hands-on, 4-hour masterclass where we build a feature-rich, fullstack application from scratch using Cursor Composer. We skip the boilerplate and focus on the exact workflows used to ship high-quality features in minutes, not days.What You’ll Master<ul><li>AI Orchestration: Move beyond simple autocomplete to manage multi-file changes and complex app logic.</li><li>The .cursorrules Framework: Learn how to enforce project standards and prevent AI "hallucinations" for consistent, professional code.</li><li>Rapid Fullstack Scaffolding: Generate type-safe database schemas and backend logic instantly.</li><li>High-Fidelity UI Iteration: Transform prompts into polished, responsive interfaces using modern CSS and component libraries.</li><li>Hardening &amp; Refactoring: Use AI to hunt bugs, clean up "spaghetti" code, and generate comprehensive test suites.</li></ul>The ProjectWe will build a modern, data-driven web application that demonstrates the power of AI-assisted development. By the end of the session, you will have a functional codebase that showcases complex data relationships, dynamic UI, and optimized state management. Who Is This For?Developers who want to eliminate repetitive tasks and focus on high-level architecture.Founders &amp; Prototypers who need to bridge the gap between an idea and a working product rapidly.Tech Enthusiasts eager to master the professional AI-native toolkit.Requirement: Bring a laptop with Cursor installed. We provide the roadmap; the AI provides the speed; you provide the vision. As this is a live online session, we encourage you to sign up ASAP to receive the pre-workshop setup guide and ensure you are ready to build from minute one.

Building Fullstack Apps With Cursor

Maurice de Beijer

<span style="color:rgb(65, 65, 65);font-family:sans-serif;font-size:16px;font-style:normal;font-variant-ligatures:normal;font-variant-caps:normal;font-weight:400;letter-spacing:normal;orphans:2;text-align:left;text-indent:0px;text-transform:none;widows:2;word-spacing:0px;-webkit-text-stroke-width:0px;white-space:normal;background-color:rgb(255, 255, 255);text-decoration-thickness:initial;text-decoration-style:initial;text-decoration-color:initial;display:inline !important;float:none">This workshop explores how standalone agents operate at the runtime level and how they differ from traditional AI pipelines. We’ll examine agent architecture, planning loops, memory models, and tool execution. We’ll also cover multi-agent coordination, including state isolation and resource control. A key focus is security and governance — capability-based access, sandboxing, and injection risks. Finally, we’ll address observability and supervision: tracing reasoning, auditing tool usage, and implementing control mechanisms for production systems. <span style="color:rgb(65, 65, 65);font-family:sans-serif;font-size:16px;font-style:normal;font-variant-ligatures:normal;font-variant-caps:normal;font-weight:400;letter-spacing:normal;orphans:2;text-align:left;text-indent:0px;text-transform:none;widows:2;word-spacing:0px;-webkit-text-stroke-width:0px;white-space:normal;background-color:rgb(255, 255, 255);text-decoration-thickness:initial;text-decoration-style:initial;text-decoration-color:initial;display:inline !important;float:none">All examples and concepts will be grounded in the Node.js stack and we will explore why Node.js is particularly well-suited for building production-ready agent runtimes — serving as the control plane for supervision, integration, streaming execution, and distributed coordination. References<span style="color:rgb(65, 65, 65);font-family:sans-serif;font-size:16px;font-style:normal;font-variant-ligatures:normal;font-variant-caps:normal;font-weight:400;letter-spacing:normal;orphans:2;text-align:left;text-indent:0px;text-transform:none;widows:2;word-spacing:0px;-webkit-text-stroke-width:0px;white-space:normal;background-color:rgb(255, 255, 255);text-decoration-thickness:initial;text-decoration-style:initial;text-decoration-color:initial;display:inline !important;float:none">: OpenClaw, n8n, LangChain.

Operating Agent-Based Systems - Overview, Configure, Run, Orchestrate, Monitor

Alex Korzhikov

Pavlik Kiselev

Claude Code is no longer just a coding assistant, it's becoming an operating system for software development. In this talk, I'll walk through how reusable templates, agents, hooks, skills, and MCP integrations can transform Claude Code into a structured, composable workflow engine. Drawing from building <a href="https://www.aitmpl.com/skills" target="_blank">aitmpl.com</a> and shipping these patterns in production at scale, I'll show how developers can stop prompting from scratch and start building on top of a shared, evolving component layer.

Templates and Components for Claude Code: The Future of AI Coding Workflows

Daniel Ávila

In this hands-on workshop, you’ll learn how to integrate AI directly into your application using TanStack AI. We’ll build a working AI chat feature end-to-end, starting from server setup and finishing with a streaming client, tool calling, human-in-the-loop workflows, and real debugging using TanStack DevTools. Through guided exercises, you’ll learn how to set up TanStack AI on the server, connect a client application to a streaming AI backend, build a functional chat interface, create your first AI tools, and implement approval flows so humans can stay in control when tools are invoked. By the end of the session, you’ll understand the core building blocks of AI-powered applications and walk away with a solid foundation for adding intelligent chat and tool capabilities to your own apps. Workshop outcomesWhen you're finished with this workshop you will:<ul><li>Understand how to set up TanStack AI on the server and wire it to a provider (like OpenAI)</li><li>Know how to connect a client app to a streaming AI endpoint and handle incremental updates cleanly</li><li>Build a functional chat UI with a solid state model for messages, streaming tokens, and tool results</li><li>Create and use your first AI tools with clear inputs, outputs, and predictable behavior</li><li>Build human-in-the-loop workflows with tool approvals so your app can ask for confirmation before executing sensitive actions</li><li>Debug and inspect your AI app using TanStack DevTools, including tool calls, responses, and streaming behavior</li></ul>What you'll learn TanStack AI gives you the primitives to build real AI features, not just a demo prompt box. This workshop focuses on wiring everything together properly, from server-side streaming to client UX, then layering in tools, approvals, and debugging so the final result is something you can confidently evolve into production features. You’ll learn the following through these exercises:<ul><li>Server setup - Configure TanStack AI on the server, connect to your model provider, and expose endpoints that support streaming chat</li><li>Streaming and SSE - Implement and consume streaming responses, understand the lifecycle of a stream, and build UI that stays responsive while tokens arrive</li><li>Chat UI and state - Build a chat interface that handles message history, partial responses, loading states, and tool outputs in a clean way</li><li>Tools - Define tools, validate inputs, return structured outputs, and integrate tool results back into the conversation flow</li><li>Human in the loop - Add approval steps for tool execution, implement “approve/deny” flows, and keep users in control when actions matter</li><li>Debugging with TanStack DevTools - Inspect requests, responses, tool calls, timing, and streaming behavior so you can troubleshoot fast and iterate safely</li></ul>Prerequisites This workshop assumes you can build and run a React + TypeScript app locally and you are comfortable working with a basic server setup.<ul><li>Basic understanding of SSE and streaming is required (we’ll use streaming heavily throughout the workshop)</li><li>Experience with React is required (components, state, props, rendering lists)</li><li>Basic TypeScript knowledge is required (we’ll rely on types for tools and structured outputs)</li><li>You will need an OpenAI API key with available credits to use during the workshop exercises</li></ul>

Building AI-Powered Apps with TanStack AI - From Setup to Chat Tools

Alem Tuzlak

Standardization pays off - but adoption is where teams bleed. An engineer’s view of adopting Netflix’s UI paved road tooling - Web Framework, Hawkins design system - covering the bumps (and fixes) with real-life examples and playbooks you can apply.

Walking the Netflix Paved Road (Bumps Included): Web Framework, Hawkins Design System

Misha Kazakov

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

Using Spec-Driven Development for Production Workflows

Erik Hanchett

AI coding assistants are evolving from simple autocomplete to autonomous agents that can interact with external systems. But how do you teach an agent to follow your workflows and use the right tools at the right time?In this hands-on workshop, you'll discover:<ul><li>What MCP (Model Context Protocol) is and how it standardizes tool integration for LLMs</li><li>How Agent Skills package domain-specific knowledge and workflows for AI agents</li><li>The key differences between MCP servers and Skills, and when to use each</li><li>How to create a custom Skill that orchestrates multiple MCP tools into a cohesive workflow</li></ul>By the end of this session, you'll build your own AI Skill that uses MCP tools — a Matrix-themed Neo fighting skill.Who should attend: This workshop is ideal for software developers who use AI coding assistants (Claude Code, Cursor, or similar) and want to extend their capabilities with custom integrations and workflows. No prior MCP or Skills experience required — just bring your curiosity and a laptop.

Let’s Teach Neo Kung-Fu: Building an Agentic Skill with MCP Tools

The hype around AI coding agents is very real, and autonomous coding systems are improving fast. In this talk, we'll explore the "Ralph Wiggum" method, where AI agents run in persistent iteration cycles until tasks are actually complete. You will learn about backpressure mechanisms to let the LLM self-correct and retry without human intervention. We will discuss how to structure the prompts, practical patterns for turning test failures into actionable AI feedback, and honest insights about when this approach works best versus where it falls flat. This is about making AI agents actually useful for real work by applying agentic engineering principles, not vibe coding. If you're curious about the future of AI-assisted development and want to see what's possible when we design systems that expect and handle failure, this talk is for you.

Autonomous AI Agents in Action With the Ralph Wiggum Method

Eddy Vinck

JavaScript engines power the web, but what does it actually take to build one, and even contribute to the ones used by billions?In this talk, I'll share the journey of creating Boa, a JavaScript engine written in Rust, and what it taught me about how JavaScript really works under the hood. We'll explore how code is parsed and executed, and the surprising complexity hidden inside the ECMAScript specification.But building an engine wasn't just a technical challenge, it was also about building a community. I'll share lessons from leading an open-source project, growing contributors, and navigating the realities of maintaining a language runtime.Finally, we'll look at how this work extended beyond Boa, culminating in contributions to V8, the engine that powers Chrome, through the implementation of Temporal in Rust. This is the story of how an open-source project can evolve from experimentation to influencing the broader JavaScript ecosystem.

Building a JavaScript Engine in Rust: Lessons From Boa

Jason Williams

In this talk, I’ll show how to instrument applications end-to-end with OpenTelemetry, capturing metrics, traces, and logs across the entire request lifecycle. You’ll learn to pinpoint errors, understand why they happen, and fix them faster – guided by real-world examples and a starter template for quick adoption.You’ll also see how to turn telemetry into automated insights using MCPs (Model Context Protocol) to generate reports from your observability stack. Using a Grafana MCP to produce incident summaries, release health reports, and diagnostics with open-source tooling.

FullStack Monitoring with Open Telemetry: End-to-End Observability for Modern Applications

Erick Wendel

Most developers using AI coding tools hit the same wall on real projects: the demos look magical, but production work falls apart. This workshop shows why — and what to do about it.The core lesson: execution is fast and cheap only when preparation is deep.What we'll build, liveFrom an empty directory to a deployed production app — a mobile-first Conference Companion App with the event schedule, speaker profiles, search, and favourites. Attendees will open it on their phones before the session ends. The four stages of shipping with AIYou'll see a complete production workflow, deliberately weighted toward the work that actually determines quality:- Research — Gathering everything the AI will need upfront: official docs, code patterns, real data. By execution time, nothing has to be searched for. This is where quality comes from.- Planning — Breaking the app into clear tasks with acceptance criteria, written live. Skipping this is why most AI builds fail.- Execution — Ten tasks running in parallel via git worktrees, orchestrated by Navigator (a Claude Code plugin) on a React/Next.js stack. Code and docs written together.- Review &amp; Ship — Quality gates (tests, lint, types, build), clean commits, merge, deploy to Vercel. Live URL shared with the room. Bonus: Human + Claude Code vs. fully autonomous agentWhile the live build runs, Pilot — our autonomous coding agent — builds the same app from the same spec, on its own, in a separate repository. At the end, we open both side by side: two working apps, two pull request histories, two live URLs. One human-driven, one fully autonomous. You'll leave withA repeatable workflow for shipping real software with Claude Code, plus concrete techniques you can apply to your own projects on Monday morning.

Advanced Claude Code — Production Workflows, Subagents, and Autonomous Execution

Aleksei Petrov

Ever wondered what it takes to power millions of voice conversations at ChatGPT's scale?When OpenAI needed infrastructure for ChatGPT's Advanced Voice Mode, they turned to LiveKit's open source infrastructure. Not a proprietary black box. Not a closed platform. Open source software that anyone can use, modify, and deploy.In this talk, I'll take you behind the scenes of building production voice AI infrastructure that handles millions of conversations:<ul><li>Why Open Source for Production AI – The technical and business reasons behind the choice</li><li>Architecture Decisions – How we built for scale, reliability, and low latency</li><li>Scaling to Millions of Calls – The challenges you don't anticipate until you hit them</li><li>Lessons Learned – What we'd do differently knowing what we know now</li><li>What's Possible Now – How you can use the same infrastructure for your projects</li></ul>This isn't a sales pitch, it's a technical deep dive with real production metrics, architectural diagrams, and honest discussions about trade-offs. You'll see the actual stack, understand the scaling challenges, and learn from our mistakes.Whether you're building your first voice agent or scaling to production, you'll walk away with insights from one of the largest voice AI deployments in the world. Because the infrastructure powering ChatGPT's voice mode is open source, and it's available to everyone.

Open Source Voice AI: How We Built ChatGPT's Voice Mode Infrastructure

Memory leaks in single-page applications are often viewed as mere technical debt, but data shows they directly degrade user experience and engagement. In this talk, we introduce MemLab, an automated framework that identifies memory leaks by simulating user interactions and analyzing heap snapshots.

MemLab: Automating Memory Leak Detection and Heap Analysis

Liang Gong

Tools like Playwright MCP (or AI) or Claude Code can generate tests for your code.Cursor can give you testing suggestions about your codebase that sounds logical within seconds also.Testing has never felt this easy before.Until the need for a full scale, seamless are effective testing strategy for your product arises.How do you know if these generated tests and suggestions really fit your standards and needs, despite looking so good?How do you, as the lead engineer, balance the generated tests across different testing quadrants, between the “what” and the “when” of a testing automation pillar and design a scalable architecture for your team, and beyond?How do you combine these AI tools to architect a scalable AI-driven testing workflow and still fully own your team’s code quality?Join my talk and let’s find out.

AI Can Generate Tests for You, Now What?

Maya Shavin

For 11 years the WhatsApp Web platform has been used by a billion people, without any consistent design system the entire time. This talk is the story of I sold the project, built one from scratch, and influenced others, to migrate it into a 1M+ LoC frontend. Plus, how this project was both boosted by AI and strongly benefits AI productivity.

Creating a Design System for 1B+ Users in the Age of AI

Noah Yamamoto

TanStack AI is an open-source project built to make it easy for developers to use AI in their applications and in this talk Alem will explain how they used AI to help them prototype concepts, solidify API's and ship the final library in under a month's time. Learn practical use-cases for AI in your day to day life through the lessons learned on the development of TanStack AI.

How We Used AI to Build TanStack AI

Who is ordering Starbucks with ChatGPT? Will an Agent just make the perfect UI for you? Do we even need websites anymore? This app could have been an API!We like using AI, but we also like using websites! Do we add AI to our site, or does our site get added to AI? This talk looks at the current landscape of agentic interfaces and the future of UI, websites and browsers.

Agentic Interfaces: Tools, Skills, Generative UI and Web MCP

Wes Bos

It's undeniable that LLMs are slowly (and not even that much) but steadily changing the way we write code. But they have a problem: once you start using something outside of their training set, the performance quickly degrades.Releasing Svelte 5 (with a pretty big syntax rewrite) right before those LLMs started to get good at code was unfortunate, but luckily, there's a way around this! MCP servers can add context for the LLM and guide our future overlords on how to write perfect Svelte code. Learn how we've built the official Svelte MCP and which techniques we used to make LLMs master Svelte 5's runes and reactivity!

How I Taught LLMs How to Svelte

Paolo Ricciuti

Yarn is the latest tool to join the Rust revolution. But is rewriting JavaScript tooling in Rust a necessity or just a trend? In this talk we'll dive into Yarn's recent updates to understand why they made the switch and how it went. We will discuss whether a fully Rust-based toolchain is inevitable and, crucially, what role Node.js will play in this new landscape.

Supercharging Your Tooling With Rust

Maël Nison

JWTs (JSON Web Tokens) are everywhere – frontends, backends, microservices – and for good reason: they're easy to pass around, self-contained, and standardized. But while JWTs can be a solid fit for authentication, using them for authorization is a decision that comes with serious pitfalls – especially in distributed systems.In this talk, we’ll explore the technical and security limitations of JWT-based authorization and explain why they're fundamentally incompatible with the needs of modern applications. From the infamous ""New Enemy Problem"" described in Google’s Zanzibar paper to the vague semantics of scope claims and the difficulty of revoking tokens in-flight, we’ll unpack the real-world consequences of treating JWTs as your AuthZ layer.

Stop Using JSON Web Tokens (JWTs) for Authorization!

Sohan Maheshwar

Modern web development still relies on a strong separation between HTML/CSS for UI and Canvas/WebGL for rendering. In practice, combining both often leads to complex synchronization logic and a series of workarounds.In this talk, we’ll first walk through how these problems are typically solved today — including scroll synchronization, frame loop timing, scissor-based rendering, and mapping DOM elements into a WebGL scene — and why these approaches tend to be fragile and hard to scale.Using a set of experiments and websites developed at basement.studio, we’ll show these patterns in practice, combining real layouts with shaders and interactive effects.From there, we’ll introduce HTML-in-Canvas and show how it simplifies many of these problems — not as a finalized solution, but as a direction that removes the need for most of the synchronization and rendering workarounds we rely on today.We’ll also cover the challenges of building UI directly in WebGL, where layout, text, and interactivity become difficult to manage, especially in environments like WebXR.

HTML in Canvas: Bridging UI and GPU on the Web

Santiago Colombatto

Tomas Ferreras

Code migrations are repetitive, time-consuming, and tools like codemods struggle to handle complex transformations without extensive manual effort. What if there was a smarter way to tackle large-scale migrations? In this talk, we explore how LLMs can take the heavy lifting out of such complex code migration and share practical learning and insights.

LLM Powered Migration of UI Component Libraries

Naval Singh

Refactoring thousands of files to break a client-side monolith is a daunting task, but when our estimation for extracting the client side monolith hit the 8-year mark, we knew manual refactoring wasn't an option, so we built an AI infrastructure engine that is currently compressing that timeline to just 6 monthsThis isn't a theoretical proposal, we are currently midway through the process, successfully migrating production code daily and compressing that timeline to just 6 months. In this talk, we'll explore the custom orchestration engine driving this reality, while you will walk away understanding how to combine the deterministic reliability of ASTs with the creative power of LLMs to solve your own "impossible" legacy migrations.

From 8 Years to 6 Months: Orchestrating AI Agents for Large-Scale Refactoring

Alon Segal

Amit Hanoch

Every minute added to your CI pipeline costs real money and real developer time. At ~45 MRs per day and ~340 pipeline runs, a single minute of pipeline overhead translates to nearly 6 hours of lost engineering time daily. This talk presents the complete playbook we used to reduce our Merge Train pipeline from about an hour to about 22 minutes — a ~64% reduction — while improving CI health from the low 80s to the low 90s percent. Covering compute instance migration (with real benchmark data from 10 runs per configuration), service test extraction, CloudWatch optimisation, linter caching, flaky test detection, and cost analysis, attendees leave with a prioritised framework for their own CI optimisation efforts. Every optimisation includes before-and-after metrics, cost impact, and the trade-offs we navigated.

Halving Your CI Pipeline – Practical Optimisation Strategies

Serhii Yakovenko

Every title that reaches Netflix's millions of subscribers passes through a gauntlet of decisions — some made by rules, some by ML models, and some by human reviewers. And with Netflix's catalog growing faster than ever, getting all of them to work together reliably, at scale, is one of the hardest problems in production systems engineering.In this talk, we'll share how we rethought workflow orchestration from the ground up to build a framework where rule-based automation, ML models, and human-in-the-loop review aren't just bolted together — they're first-class citizens in the same pipeline. We'll get into the real challenges: routing decisions across heterogeneous components, isolating failures so a single bad signal doesn't cascade, and closing the feedback loop across the entire system. Along the way, we'll show why the architectural choices that make this work today are exactly what make AI agent integration tomorrow feel like a natural evolution — not a retrofit.If you've ever tried to build a production pipeline that doesn't fall apart when one piece changes — this one's for you.

Orchestrating Content Workflows at Netflix Scale

Pratyusha Singaraju

The JavaScript ecosystem is moving towards a standardized module system, and Node.js is evolving to aid its adoption. What actually happens when Node.js loads an ES module today? This talk walks the full pipeline - resolution, loading, parsing, compilation, linking, instantiation, and evaluation. We will cover how the work is split between V8 and Node.js, where Node.js differs from browsers and bundlers, and the recent changes in Node.js that unlocks new patterns for better interop, performance, and customization in ESM. You will leave with a clearer mental model of how ESM is loaded in Node.js, shed obsolete knowledge and misconceptions, understand where to look when your modules don't work, and learn about the new capabilities that will help you write, run, and share ESM code better on Node.js today.

Life of an ESM in Node.js – and How It's Changing for the Better

Joyee Cheung

AI agents are almost everywhere, but deploying one yourself still feels like it requires a PhD in infrastructure. What if it didn't? This talk breaks down what AI agents actually are, how they work, and why Cloudflare's platform makes it ridiculously easy to build and ship your own. Everything written with the language you love (or hate): JavaScript.We'll cover the agent loop, introduce MCP (Model Context Protocol) as the glue that connects agents to real world tools, and walk through Cloudflare's stack, from Durable Objects for stateful execution to Workers AI for inference.By the end, you'll deploy your own agent using a single command from a shared GitHub repo. No PhD required.

Click. Ship. Done. AI Agents on Cloudflare

Jan Peer Stöcklmair

AI is writing code faster than ever. But there's a gap: the gap between "it works" and "it works correctly."As a QA Automation Engineer with 9 years of experience, I've developed the instinct to see what breaks before it breaks. AI generates clean code that hides catastrophic bugs in plain sight. This talk teaches you "the tester's eye" – the ability to spot edge cases, boundary conditions, state issues, and silent failures that AI confidently creates.You're reviewing AI code with developer eyes trained to see "does this solve the problem?" Testers see something different: "what are all the ways this could fail?" I'm teaching you to see both.

Think Like a Tester: What to Look For in AI-Generated Code

Wendy Erdheim-Poch

Monorepo Metamorphosis: Reducing CI Load by Over 65% with Nx, pnpm &amp; Predictive Build GraphsDoes your CI feel slower every time your monorepo grows? In this talk, I’ll share how we transformed a 200+ project JavaScript/TypeScript monorepo by applying predictive dependency graphs, Nx task-hashing, pnpm’s content-addressable workspace, and horizontally scaled runners to eliminate redundant work and shrink build+test cycles by more than 65%. If you’re looking to break the cycle of ever-increasing CI times and unlock real delivery velocity, this session provides a clear and practical blueprint.

Scaling JavaScript Monorepos at Enterprise Level: Lessons From 200+ Packages

A look through the main trends revealed by this year's State of Web Dev AI survey results, based on data collected from over 6800 developers.

The State of AI for Web Development

Sacha Greif

We look into how bundlers place modules into output files in a process called "chunking". What are the competing metrics that can be influenced by chunking? Why is CSS and JS chunking completely different? What are performance considerations for large apps? How does JS chunking and CSS chunking work in Webpack/Turbopack/Next.js (on a high level)?

Chunking

Tobias Koppers

Auth bugs rarely show up as “login is down.” They show up as redirect loops, stale sessions, broken refresh flows, and permission leaks after “small” changes. This talk walks through one real incident pattern and delivers a repeatable playbook for debugging fast and adding guardrails that keep auth stable in production.

Auth Under Attack Catching JavaScript Auth Failures in Production Fast

Viola Lykova

Billion of users are starting their searches on ChatGPT instead of Google.For JavaScript developers, this isn't just a trend, it's a new runtime: ChatGPT Apps. These new apps serves as a replacement for traditional web and mobile applications: interactive, tool-powered experiences living inside the world's fastest-growing AI platform. They benefit from packing an LLM right within the application.Giants have already shipped their own: Booking, Expedia, Accor, Figma, Uber... Now it's time to build yours!I built Skybridge, an open-source TypeScript framework for building them, and it comes packed with everything you'd expect from a modern JS dev environment. Come and learn how to build in this new ecosystem!

Building ChatGPT and MCP Apps with All the Comfort of Modern TypeScript DevX

Frédéric Barthelet

After training and coaching more than 400 tech leads across companies and industries, one pattern keeps repeating: when tech leads struggle, it’s rarely a technical gap.In this talk, Anemari Fiser shares the most common challenges tech leads bring into coaching sessions - overload, unclear expectations, ownership confusion - and assumed alignment and why “getting better technically” almost never fixes them.Drawing from real coaching and training examples, the talk explores where tech leads get stuck, what they think the problem is, and the small but meaningful shifts that help them move forward.

400 Tech Leads. Same Problems. None of Them Technical

Anemari Fiser

MCP Apps are the last piece in moving toward a new web - one that's "nearly" headless. Autonomous agents, not humans, will interact with most websites through MCP, APIs, and other data channels. Websites and browsers become obsolete, replaced by personal assistants that orchestrate tasks on our behalf. In rare cases, agents will fall back to browser capabilities to navigate sites that aren't yet agent-ready.But we'll still need the last mile.Some moments still require human eyes and human input: choosing a seat at a venue, completing a check-in, reviewing a 3D model, verifying intent on important decisions. This is where MCP Apps come in - letting tools, websites, and services send composable, interactive chunks of UI directly to agents, exactly when needed, maintaining brand and identity.We'll explore the full cycle of this nearly headless web: the infrastructure required to support autonomy and trust, the new UI layer, and how assistants are becoming the new browsers.MCP Apps redefine the web's interface. Headless, but with a human eye at the end.

MCP Apps – the Next Web

Liad Yosef

Ido Salomon

JavaScript uses Garbage Collection (GC) for memory management. As a result, many developers that use JavaScript based systems, such as NodeJS, assume that they’re free of memory issues. Unfortunately this is incorrect, and many NodeJS-based services suffer from memory management problems such as leaks and excessive GC CPU cost. But finding, understanding, and resolving memory issues can be very challenging, because a problem in any part of the application impacts the application as a whole. Also, they may only manifest under load, in production environments. In this session I will explain how to find and fix such issues using the heap dump feature that is built into NodeJS. And I will show how to use the DevTools memory panel to analyze such dumps.

Taking a Dump: Using Heap Dumps to Find and Fix NodeJS Memory and CPU Problems

Dan Shappir

Join the "Ecosystem Performance" initiative to explore our mission to revolutionize the JavaScript ecosystem. We tackle bloated, slow, and outdated dependencies in popular open-source libraries, replacing them with optimized alternatives or crafting our own superior solutions. Our goal is a faster, more secure web, enhancing the developer experience by reducing node_modules overhead and improving overall efficiency. Discover what we've achieved so far, our ongoing efforts, and how you can contribute to shaping a leaner, more performant future for web development.

De-bloating the Web: The "Ecosystem Performance" Initiative (e18e)

Ulrich-Matthias Schäfer

Battle-tested applications with peer-to-peer OTA updates are running in production. Rapidly growing with millions of users added monthly.Using a module and a CLI tool, you too can deploy a peer-to-peer production application with drastically lower complexity than traditional deployment means.

No Servers, No Cloud, No Masters: Make P2P Apps

David Mark Clements

Black Friday is one of the most challenging times for any system, as traffic can increase by four to ten times within a short period. Teams often prepare by running performance tests, but they may not be using the right testing method.In this talk, I will present a real-life situation where a system seems fine during testing but crashes when faced with actual conditions.The main problem isn't the system itself, but the way the test was set up.This topic is especially important for teams developing and expanding web applications, especially during high-traffic events like Black Friday.It bridges the gap between performance testing strategies and real-world system performance, while also considering business impact.

Black Friday: Would You Choose the Right Performance Test?

Oleh Koren

As the pendulum of web development swings back towards the server, streaming has become increasingly popular. Specifically, out-of-order streaming.Let's build our very own simplified version to explore how it works, what problems we are trying to solve, and what this future of web development looks like.

Out-of-Order Streaming – The Future of Web Development

Julian Burr

Sooner or later, every team faces the same question: how do we migrate from legacy code to a modern framework? Should we take the “big bang” approach and rewrite everything from scratch, or should we migrate progressively, piece by piece? In this talk, I’ll share real-world stories from large-scale frontend migrations and highlight the trade-offs of both strategies. We’ll explore the risks of freezing development for months, the complexity of running two worlds in parallel, and the decision-making criteria that help teams pick the right path

Rewrite or Refactor? How to Safely Move Legacy Apps to Modern Frameworks

Sylwia Laskowska

Deno has quietly evolved into far more than a simple server-side runtime. With built-in TypeScript, OpenTelemetry integration, ngrok-like network tunnelling, and deep Node.js compatibility, it's already a powerhouse; but we've been working on something bigger. In this talk, I'll introduce Deno Desktop: a brand new capability that completely changes what you can build with Deno and a single 'deno compile' command. If you've ever wished the JS runtime could meet you where your users actually are, you won't want to miss this one.

The Latest From Deno

Leo Kettmeir

Accessibility can often be presented as a checklist but why do your accessibility tests with assistive technology not perform the way you intended? The hidden relationship between browsers, accessibility APIs and assistive technology may be the answer to your frustrations. Understanding this may be the necessary tool you need to smoothen your debugging process.

Browser, API and Assistive Technology: A Love Triangle

Tshepiso Lehutjo

Code review has come a long way. We’ve evolved from manual inspections and email patches to modern pull requests and automated testing. Yet, one big problem remains: developers are still stuck waiting on human approvals. Join me for a walk through the history of code review to see how our processes have adapted over the last 30 years. We'll examine the limits of our current workflows and explore how the new era of AI-assisted reviews is finally solving the code review bottleneck.

A Brief History of Code Review (And What's Next)

Santosh Yadav

Migrating to a micro-frontend architecture promises scalability, faster development cycles, and autonomous teams but the journey is rarely straightforward. Drawing on real-world experiences and insights from modernising 100s of companies, this talk explores the practical lessons, challenges, and trade-offs companies encounter when adopting micro-frontends.You’ll learn about strategies for defining clear boundaries, handling inter-team dependencies, evolving your architecture incrementally, and avoiding common pitfalls that can derail projects.

Designing a Migration to Micro-Frontends

Luca Mezzalira

Most technical talks teach you how to write clean, scalable, maintainable code. This one does not. Here you will learn how to write code that confuses, deceives, and breaks things in unexpected ways... on purpose. And on top of that, in JavaScript.Discover how to:<ul><li>Hide bugs so well that even you cannot find them</li><li>Create features that break just by looking at them</li><li>Design programs that only work on your local machine</li><li>Develop functions that return anxiety</li><li>Implement code structures that are illegal in 42 countries</li></ul>Because if nothing and no one understands your code... they cannot fire you. This is the talk you did not know you needed. Join me, and together we will write code so twisted it would make a goat throw up.

Software Craftless: Writing Code That Would Make a Goat Vomit

César Alberca

Improving the autocomplete in MongoDB's database CLI seemed like a great idea. But when the team tried to flip the feature flag, things quickly started to go sideways: A story of memory leaks, bugs that touch the very core of JavaScript as a language, and hard-learned lessons about testing and performance.

A Leak in the Shell – How Refactoring Autocomplete Broke Us and How We Fixed It

Anna Henningsen

JavaScript tooling is fast until it isn't. As projects scale, even well-designed JS-based tools start to hit ceilings around cold starts, dealing with large dependency graphs, and CPU-heavy transforms. The obvious answer seems to be "rewrite it in Rust" except that reality is messier.This talk is a deep dive into what actually happens when you introduce Rust into a JavaScript-first toolchain, with Vite as the core example. We'll explore how Vite’s architecture enables selective rustification, and what we learned from building hybrid pipelines that mix JavaScript and Rust without wrecking DX.

Rustifying Vite: Designing a Hybrid Toolchain for the Real World

Alexander Lichter

Profiling JavaScript is mostly easy. However, how do you profile gnarly performance issues? In this talk, you’ll learn a practical AI-assisted workflow for finding rendering bottlenecks fast. Using a real-world CSS performance bug, we’ll cover techniques like commit bisection, standalone reproductions, synthetic stress tests, and auto-generated lint rules to prevent regressions. We choose CSS because it is famously difficult to profile -- there are no stack traces, obvious breakpoints, or clear debugging workflows, which is why many rendering bugs go unfixed until users complain that the page feels slow. However, the same methodology can be used in dealing with other performance issues. You’ll also see how to use the Chrome DevTools MCP to give Claude direct access to a live browser session and accelerate investigation without replacing engineering judgment. The result is a repeatable process for going from “the page feels slow” to a pinpointed line of CSS in under an hour.

Debugging Performance With AI

Bernie Sumption

For over a decade, Node.js documentation relied on legacy tooling, despite being the critical source of truth for @types/node, Bun, Deno, and AI models. In this talk, we unveil the engineering behind @nodejs/doc-kit – the modular successor to Node’s documentation engine. Discover how we parse massive ASTs and leverage modern Web Standards to solve complex rendering and accessibility issues, creating a high-performance experience designed to delight humans and power the ecosystem.

From Legacy to Delight: The Future of Node.js DX

 Claudio Wunder

All it takes is a module and a CLI tool to build and deploy production peer-to-peer applications. In this workshop:<ul><li>Build a realtime peer-to-peer application</li><li>Connect with others on your own application, completely peer-to-peer.</li><li>Understand how to deploy, including production practices, principles and tooling</li></ul>This is for anyone who builds with JavaScript and anyone who deploys applications.

Web Engineering Summit 2026

The full-stack excellence conference