The opening keynote. Elena takes the audience on a tour of the web platform's most transformative recent additions — from WebGPU to View Transitions to baseline support for container queries. She live-demos a full-stack application running entirely in the browser and makes the case that the gap between native and web has never been smaller.

Modern devices support 120Hz displays, but most React apps struggle to maintain 60fps during complex interactions. Ryan demonstrates a systematic profiling workflow using browser DevTools, React profiling tools, and custom performance marks to find and fix render bottlenecks — from expensive selectors to unnecessary re-renders to layout thrashing.

Modern video compression on the web is stuck between bloated codecs and unacceptable quality tradeoffs. Dinesh presents Pied Piper's middle-out compression approach adapted for browser-based video delivery — achieving dramatically better compression ratios without sacrificing visual fidelity. He covers the WebCodecs API, adaptive bitrate strategies, and the real-world performance gains from rethinking how video data flows from server to screen.

Cartwell's frontend monorepo contains over 500 packages, dozens of apps, and is contributed to by 300+ engineers daily. James shares the hard-won lessons from building and maintaining this system — from dependency management and build caching to code ownership and migration strategies that don't break everything.

Container queries have shipped in every major browser, but adoption in production remains low. Mei-Lin shares Roamly's journey of replacing hundreds of JavaScript-based responsive components with pure CSS container queries — the migration strategy, the surprising edge cases, and the performance wins that came from removing resize observers entirely.

Well-intentioned ARIA usage often makes interfaces less accessible, not more. Priya walks through the most commonly misused ARIA roles and properties — live regions that fire too often, menu roles on navigation, dialog traps that trap too much — and shows how to audit and fix them using your browser's built-in accessibility tools.

AI coding assistants are everywhere, but how much do they actually help? Kwame presents data from Trackwise's internal study of AI tool adoption — what tasks they accelerate, where they introduce subtle bugs, and how his team built guardrails that let engineers use AI assistance confidently without sacrificing code quality.

What if you could get the benefits of SSR — fast first paint, SEO, progressive enhancement — without adopting a heavy meta-framework? Julia demonstrates how Dawn's built-in server and web-standard APIs make it possible to build server-rendered applications with vanilla HTML, CSS, and minimal JavaScript.

Cumulative Layout Shift remains one of the most frustrating user experience problems on the web. Aisha breaks down the root causes — from font loading to dynamic ad injection to lazy-loaded images — and presents a systematic approach to achieving zero CLS scores using modern CSS techniques and resource hints.

Audio-heavy web applications present unique accessibility challenges that go beyond alt text and captions. Fatima shares how Spectra's team redesigned the web player's interface to work seamlessly with screen readers, keyboard navigation, and alternative input devices — without compromising the rich, visual experience that sighted users expect.

Code generation is only as good as the architecture underneath it. Gilfoyle walks through the design of Son of Anton — Pied Piper's AI-assisted code generation system — from training data curation and model architecture to the custom server infrastructure that runs it. He covers the hard tradeoffs between latency and accuracy, why most AI coding tools get context windows wrong, and the systems engineering required to make machine-generated code actually trustworthy in production.

Design tokens promise a single source of truth, but the reality is messy — different platforms, different formats, different constraints. Sarah presents Tessera's approach to generating type-safe token APIs for web, iOS, and Android from a single token definition, using code generation to eliminate the drift between design and implementation.

Blaze's speed isn't magic — it's the result of deliberate architectural decisions about module resolution, dependency pre-bundling, and HMR propagation. Carlos opens the hood on the bundler's internals, explaining how native ES modules and modern compilation tools work together, and what the team is planning next.

Your browser's developer tools contain powerful CSS debugging features that most developers don't know exist. Lucas demos the Flexbox and Grid inspectors, the font editor, the animation timeline, and the container query visualization tools — showing how each one can shave hours off common layout debugging tasks.

Server Components promise smaller bundles and faster pages, but the mental model shift is real. Marcus cuts through the theory and focuses on the practical: when to use client vs server components, how data fetching patterns change, what happens to your existing state management, and the gotchas his team hit building real features at Nimbus.

When your user base spans every device, network condition, and browser version on the planet, performance optimization looks very different. Oliver shares Crestline's approach to real-user monitoring, adaptive serving, and the INP-focused optimizations that improved interaction responsiveness for over a billion monthly users.

Most component libraries claim accessibility support, but the screen reader experience often tells a different story. Naomi demonstrates real-world failures she's found in popular UI libraries, explains why they happen, and walks through the process of building components that genuinely work with assistive technologies across platforms.

Every pull request deserves a live preview, but spinning up isolated environments for hundreds of daily PRs is an infrastructure challenge. Tom explains how Nimbus's preview deployment system handles ephemeral environments at scale — from instant cold starts and database branching to URL routing and automatic cleanup.

Luminary's browse experience needs to feel instant despite loading personalized content from dozens of microservices. Devon reveals how his team uses streaming server components with progressive rendering to show meaningful content in under 200ms, and the architecture patterns that make selective hydration practical at their scale.

Paypath processes billions in payments, and every form field is a potential point of abandonment. Hannah presents hard data on how accessibility improvements to the checkout flow directly increased conversion rates — proving that accessible design isn't just the right thing to do, it's measurably better for business.