Schedule

React gives developers a false sense of security—especially in the era of AI-assisted code and Server Components. Faster abstractions don’t remove risk; they shift it. This talk exposes common front-end security mistakes in modern React apps (including trends shaping React development in 2026) and shows how attackers exploit blurred client–server boundaries. You’ll leave with a clear mental model of modern React threat surfaces and practical techniques to build defensive applications that hold up in 2026.

TanStack Start gives you three ways to run code on the server. Server functions, server routes, and server components. In this talk we'll take a look at what each does, why you would use one versus the other, and the drawbacks of each.

TypeScript’s type system is uniquely powerful, but most developers only scratch the surface of what it can do.In this code-driven session, you’ll explore some of the weirdest and coolest features of TypeScript: from the infer keyword and recursive types to using types for arithmetic and even recreating Wordle entirely with Typescript types.You’ll discover fascinating tricks that might seem extreme and nerdy, and wonder when you’d ever need them. Spoiler: maybe rarely; but sometimes, these quirks can come in especially handy. More importantly, it’s just plain fun to explore the limits of TypeScript’s type system.

A requirement arrived with a simple solution: add stricter address validation so customers cannot proceed with invalid addresses.But this address form lived inside critical payment and ordering flows, where adding friction could harm payment completion, purchases, and customer experience.In this talk, I’ll walk through a production case study of how we reframed the problem from “prevent invalid addresses” to “collect more valid addresses,” explored address autocomplete as a lower-friction solution, defined success and guardrail metrics, and chose a release strategy that helped us learn without putting the funnel at unnecessary risk.Attendees will leave with three practical questions they can apply to their own frontend work: what are we really building, what impact are we looking for, and how should we release it?

Barrel files — those innocent index.ts re-export hubs — are one of the most popular patterns in the React ecosystem, and one of the most expensive. In dev mode there is no tree-shaking: a single `import { Button } from '@/components'` drags every re-exported module into the compile graph. I measured just how much that costs. In a synthetic Next.js lab, shrinking a 2000-module barrel down to 200 re-exports cut dev-server memory growth by roughly 88%.

React performance is not only about Lighthouse scores. This talk shows how to build React and Next.js applications that stay fast on slow networks, low-end devices, and real production conditions. Amani Kanu will share practical patterns for reducing JavaScript cost, avoiding unnecessary renders, improving data loading, using smarter caching, and designing user experiences that remain usable when network speed and device quality cannot be guaranteed.

When you think of it, browsers can be the perfect containers for running all sorts of workloads - Everybody has them, each tab is an isolated environment and they have a very rich API. So why not use the browsers in your organizations to act as containers to run your workloads and save money on servers? In this session I’ll explain the concept and demonstrate it running javascript (of course!) tasks for AI, concurrent batching, PDFs creation and more. This is the new cloud native!

Reviewing PRs is something every engineer should be doing, regardless of how senior or junior you are or how new you are to a team or codebase. It's what keeps our codebases manageable and our code quality high... if we do it right.Ultimately, we're responsible for every line of code that gets merged into our codebase. In this talk, we'll cover specific strategies to become the best code author and reviewer you can be and use PR reviews as a mentorship exercise in your teams.

Software development is fundamentally an exercise in composition. We take big, complex problems and organize them into smaller, solvable parts. So the question isn’t whether you’re composing or not. It’s whether you're composing with intention.We aren’t here to rehash “composition vs inheritance” or preach about the dogmatic use of the latest architectural trend.

We’ve all seen flashy web demos of AI agents streaming dynamic React components. But when you ship these features to production, your biggest bottleneck isn’t prompt engineering-it’s the cloud invoice. A single rogue frontend re-render loop or an unoptimized context window can quietly drain thousands of dollars in API costs overnight.My talk introduces a pragmatic, full-stack `` architecture built directly into modern React applications. I will show you how to build a two-tier defense system: using Next.js Server Components for semantic caching and dynamic LLM routing on the server, paired with custom client-side hooks that act as financial circuit breakers.

Publishing a shared component library feels like a milestone, until a single change breaks multiple applications at once.While working on a monorepo at EPAM Systems powering 8 production applications for a global supply chain platform, we built a shared ecosystem of independently deployable frontend packages: authentication, navigation, app shell, user profile, and UI components. On paper, it promised consistency and speed. In reality, it introduced a new class of problems, subtle, cross-app, and often hard to debug.A mismatch in React versions led to duplicate instances and unpredictable behavior across apps. Small feature requests from different teams slowly turned shared components into overly flexible, inconsistent abstractions.

A React tree wrapped in an Electron cross-OS runtime, orchestrating a PDF engine without blocking the main thread. This talk walks the real code: how workers perform optical character recognition against an OffscreenCanvas while the event loop keeps rendering, uninterrupted. Heavy garbage collection events and memory allocation are kept off the main thread.

Moving from junior to mid-level to senior is mostly about improving your technical skills, but moving into technical leadership is different. It's less about producing more and better code, and it's more about deploying your technical experience for the purposes of enabling others. This certainly requires a body of technical experience, but it also requires a patience for politics, professionalism, and humility.

This talk digs into what it really takes to run LLMs efficiently on mobile hardware in a React Native environment. We’ll examine the constraints teams face - memory limits, model loading strategies, inference performance, platform-specific APIs - and how they shape real-world product decisions. From there, we’ll introduce a React Native library that provides two complementary ways to integrate on-device AI: cross-platform, state-of-the-art models that run locally on both Android and iOS, and a dedicated path for leveraging Apple Intelligence capabilities on supported iOS devices.We’ll walk through the architecture, usage patterns, and trade-offs of each approach, and discuss best practices for delivering smooth, low-latency AI experiences without relying on the cloud. We will cover both native libraries for mobile AI & LLM model inference, and the available wrappers for React Native, along with the trade-offs, capabilities, hardware compatibility, model format compatibility and compile-time model optimizations (operator fusing, vectorization, memory planning, operations accelerated for specific hardware) considerations so that the audience is aware to pick the best solution for their specific use cases.

What happens to your design system, your code quality standards, and your developers' wellbeing when AI is writing significant portions of your frontend, faster than any review process can keep up? Jaayden Halko is a Senior Frontend Engineer at Coder, where he has worked on AI developer tools: Mux, a parallel AI coding agent multiplexer, and Coder Agents, a self-hosted platform for delegating development work to coding agents. In this talk, he shares the unexpected frontend challenges that emerged when AI built much of the UI, including agents building their own interface. You'll hear what happened when code reviews became optional, whether AGENTS.md files and agent skills meaningfully improve AI-generated UI quality, how different models have distinct aesthetic preferences that drift your design system and how UI design choices contribute to or mitigate developer burnout in AI-heavy workflows.This is a practitioner's talk on the decisions, trade-offs, and what AI-native agent interfaces need to become.

What does it take to build a React UI that talks to an AI agent, streams responses in three languages, and runs on both WhatsApp and the web — in production? In this case study, I'll share hard-won lessons from shipping a multilingual disaster risk awareness platform for Sri Lanka, covering real-time streaming UIs, auth-aware chat components, and the React patterns that make AI agents feel alive rather than laggy and broken.

Most AI agents touching a React app today do it the crude way, scrape the DOM, guess at selectors, simulate clicks and hope. WebMCP proposes something different: defining explicit tools, backed by JSON schemas, that give an agent a real contract instead of a markup tree to reverse-engineer. I built a small two-agent setup to actually test that contract against real React state, not just read the explainer. Some of it worked cleanly, plain state, simple mutations expose well as tools.

What if your React application could run its own AI model, remember context, and perform AI tasks without sending data to a backend?Modern browsers are gaining the capabilities needed to make this possible. Local model inference, Web Workers, browser storage, and streaming APIs allow us to move parts of the AI runtime directly into the browser.In this talk, we'll build a small React application powered by a local Gemma / Kimi model and progressively turn it into a browser-native AI runtime.We'll focus on three building blocks: running inference locally, giving the application persistent memory, and moving AI work into background workers. Along the way, we'll see how this changes the way we think about React architecture and what belongs in the frontend.The result is an AI application that can work locally, keep its context, and continue processing without depending on a cloud-hosted AI API.

Client-side AI is everywhere. With Transformers.js and WebGPU, we can run ML models directly in the browser.. But should we? In this talk, we'll explore when client-side AI makes sense and when it doesn't.

Ads Manager powers 84% of Meta's Ads Revenue, but its decade-old codebase was stuck on React class components — blocking modern patterns like hooks, Relay, and React Compiler. Manual migration of 10k+ components class to functional component was impractical. In this talk, I'll show how we built an AI codemod pipeline using LLMs that achieved a 5x speedup, migrating 3k+ components with a 99.6% success rate. I'll cover the tradeoffs between AST and AI codemods, how to classify components by complexity for targeted prompts, and the grading/eval strategies that made non-deterministic AI agents production-ready.

Supply chain attacks are no longer a theoretical threat - they are a daily reality. GitHub repositories, npm packages, VS Code extensions, biggest open-source libraries: all have been weaponized to compromise thousands of developers and their users at once. New incidents surface every day, each one larger than the last, and no project is out of reach.Every breach gets its post-mortem. But by the time you read it, the next attack is already being planned.This talk is about getting ahead of it.

What if the key to breaking into tech communities wasn't a perfectly curated LinkedIn profile or a flawless resume...but a well-timed joke? In this lightning talk, Roxy shares the unconventional "trolling" strategies that she used to get noticed and create real opportunities in tech. From showing up everywhere to leaning into memorable (and sometimes embarrassing) moments, these tactics built her network in ways she never expected, landing her invitations to emcee RenderATL, star in teh Web Dev Challenge, and land her first role in tech.This talk is for anyone who has ever felt like they were on the outside of a room they "technically" belonged in. :) Whether you are a senior engineer who has never spoken at a conference, or a newer developer trying to find your people, you'll walk away with an actionable list of actions to expand your network, get noticed, and create your own opportunities.