October 23 - 26, 2026
React Advanced
London, UK & Online

React Advanced 2026

We will be diving deep

Full remote ticket included with Multipass.

Get ready for an annual deep dive into the latest trends in React and Web development. Learn from engineers behind the framework ecosystem and early adopters at the main React Conference in the UK.

The concept of the event is both about covering all you need to catch up on in the React ecosystem, combined with deep technical exploration of the latest architectural trends, new feature adoption, and efficient ways to solve complex problems.

Engage in discussion rooms, hallway track with experts, hands-on practical workshops, and tens of insightful talks. Engineers of any level are welcome but be prepared for hardcore.

Modern React Architecture
Nov 9, 15:00
Modern React Architecture
WorkshopPro
Brad Westfall
Brad Westfall
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 along with React's "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.
Register
When Waiting Becomes a Feature: Rethinking Performance for AI Applications
Upcoming
When Waiting Becomes a Feature: Rethinking Performance for AI Applications
For decades, frontend performance has been guided by the simple principle that faster is better. We optimize load times, reduce latency, and remove every unnecessary delay from the user journey.While building streaming AI interfaces with React, I discovered that traditional performance metrics do not tell the whole story. In AI products, users do not just experience a before and after. They experience a during. They watch responses stream in, follow reasoning traces, observe tool execution and form opinions about the system long before an answer is complete.In this talk, I want to share lessons learned from building production AI experiences, including streaming architectures, rendering strategies and real-time interfaces. We will explore why time to first token, streaming consistency and the quality of the waiting experience can matter just as much as raw speed.You will leave with practical insights for building AI-powered React applications and a new perspective on what performance means when users are watching the system think.
How Not to Use TanStack Query
Upcoming
How Not to Use TanStack Query
We built a product fully on TanStack Query and skipped adding a state management layer. It worked for a while, then it broke in ways we didn’t expect.This talk dives into how TanStack Query works, what we got wrong, and how to use it properly. From missing optimistic updates to confusing server and client state, we’ll break down the lessons learned and what patterns actually scale when your app grows.
Self-Healing UI: Beautiful Idea, Brutal Data
Upcoming
Self-Healing UI: Beautiful Idea, Brutal Data
This talk is about an experiment I wanted to try and carried out. I wondered what if we gave React components self-healing properties? What if instead of developers checking Sentry for crashes and then fixing and sending it to prod, the component fixes the crash on its own at runtime? In this talk, we will discuss this exact possibility and whether we can really make it work and what the drawbacks are...
Building MCP Apps With React and GraphQL Patterns You Already Know
Upcoming
Building MCP Apps With React and GraphQL Patterns You Already Know
You know how to build client apps—but where do client developers fit in the new world of ChatGPT and MCP? If you’ve used GraphQL before, it turns out your knowledge translates directly. This talk demonstrates how to build MCP apps using Apollo Client’s new open source AI apps integration along with the open source Apollo MCP server with patterns you already use:Fragment colocation → Tool design: Structure MCP tools as component data requirementsQuery optimization → Tool call patterns: Minimize LLM roundtrips with the same performance thinkingType safety → Tool schemas: Apply GraphQL’s type discipline to MCP definitionsA live demo builds an MCP app querying a GraphQL API, showing how best practices from GraphQL client development apply to MCP apps.
When React Meets Rock: Building Safe and Performant UI for Live Entertainment
Upcoming
When React Meets Rock: Building Safe and Performant UI for Live Entertainment
At TAIT, we build the full automation stack behind the world's biggest live experiences, from the systems that move stages and fly performers to the React interface that operators use to control them. Our frontends can't lag, freeze, or crash while hardware is moving, or someone can get hurt. This talk covers the architecture and performance patterns behind that interface, and what it teaches us about building any React app where failure isn’t an option.
Teaching AI to Write Production-Ready React
Upcoming
Teaching AI to Write Production-Ready React
How many times have you had to tell Claude Code to stop reaching for useEffect?React’s flexibility is a strength for developers, but it often leads AI tools in the wrong direction, introducing subtle bugs and drifting away from production-ready code without clear guidance.In this talk, Abhijeet Prasad, maintainer of Braintrust’s AI observability SDKs, shares practical ways to keep your agents on track and writing production-ready React. You will start with simple guardrails and skills that shape better behaviour, then move toward a more powerful setup: an eval pipeline that continuously improves your agents by driving updates to lint rules, skills, and agent instructions.
DevOps for React Developers: From Code to Production
Upcoming
DevOps for React Developers: From Code to Production
Workshop
Kristiyan Velkov
Kristiyan Velkov
Mentorship available
This workshop bridges the long-standing gap between React developers and production-ready delivery. Many front-end developers know how to build great interfaces but they stumble when it comes to building, testing, deploying, and monitoring those apps in real-world environments.This workshop gives React developers the DevOps superpowers they need.You’ll learn how to:Dockerize your React application for development and production following best practices from Docker Captain Leader.Build scalable CI/CD pipelines using GitHub ActionsOptimize your apps for performance and reliabilityThis is not theory. It’s not a shallow overview. This is a production-focused, real-world workshop by a front-end developer who lives and breathes this every day.
Register
React Server Components Are a Serialization Format, Not a Framework Feature
Upcoming
React Server Components Are a Serialization Format, Not a Framework Feature
React Server Components are often treated as a framework feature, but they make more sense as a serialization format and a runtime primitive. This talk presents how that mental model changes the way we think about rendering boundaries, composition, and system design in React. Drawing on real implementation experience, I'll show why this shift matters and what it makes possible beyond the assumptions of a single framework, especially for complex systems like a React CMS, where server-first composition and serialization directly shape how content, workflows, and UI are modeled.
Claude Code: Black Belt
Sep 9, 13:00
Claude Code: Black Belt
Workshop
Pawel Sawicki
Pawel Sawicki
Stop prompting. Start orchestrating. In four intense hours you'll go from using Claude Code like a faster autocomplete to commanding it like a senior engineer commands a team: engineering its context, deploying fleets of subagents, locking it down with hooks, and turning it loose on work that runs without you.Every Claude Code user hits a ceiling where the easy wins run out. The agent handles small stuff beautifully, then loses the thread on anything real. The difference between that ceiling and real mastery isn't better prompts. It's control. This workshop is about control.You'll spend the whole four hours inside CLASH, a real full-stack application, handed to you fully built so nothing stands between you and the hard parts. A serious codebase is the point: it's the only place agentic engineering shows you whether it actually holds up.The throughline is context. Treated carelessly, the context window fills with noise until the agent drifts. Treated as a resource you engineer, it becomes the biggest lever you have. From there the toolkit opens up. Repeatable work becomes a reusable Skill. Noisy, exploratory work goes to subagents that run in their own isolated context, several at once when the job allows. Hard rules become hooks the agent cannot cross. Your own systems come into reach through MCP.Then you let go of the wheel, carefully. The same agent that pairs with you can run headless in a pipeline, drive a long task to a defined finish on its own, or live inside your software through the Agent SDK. We close by setting two greenfield methodologies, Spec Kit and BMAD, side by side, so you leave knowing not just how to drive the agent but which approach fits which problem.Two ideas hold it together: context is king, and you push it, you own it. This was never about generating code faster. It's about staying in command while the agent does more.This is an advanced session for engineers, tech leads, and architects who already use Claude Code every day and want to reach the top of the curve. We move fast, and we start in the deep end.
Register
The Internals of compile-time CSS-in-JS
Upcoming
The Internals of compile-time CSS-in-JS
Styled-components lost against Tailwind, partly due to better performance while trading it for a unique API. Can’t you have both, a fast runtime and a familiar API?We replaced styled-components with a build-time compiler in next-yak without changing a single line of user code and saw surprising results: INP improved over 10%, our SSR latency and our pod count dropped significantly. But the path there wasn’t simple.This talk is about three problems that make compile-time CSS-in-JS genuinely hard: dynamic interpolations, cross-file references and build-time evaluation. I will show what we solved, how we solved it and what we couldn’t fully solve and why the remaining gap is a harder problem than it looks. 
The Power of Use: Resource-Driven Performance in React 19
Upcoming
The Power of Use: Resource-Driven Performance in React 19
React 19’s new use() API is often introduced through data fetching: pass a Promise, suspend while it’s pending, and render when the data is ready. But for many React apps, the bigger performance problem is not just waiting for data — it is shipping, executing, and hydrating too much JavaScript too early. Because use() can suspend on any Promise, it opens a bigger performance opportunity: what if a React app could wait not only for data, but for any resource that determines when different parts of the UI should load, render, or hydrate?In this talk, we’ll explore use() as a primitive for resource-driven performance. We’ll start with the familiar data-fetching pattern, then expand the model through several different use cases: selectively loading component code and remote modules, delaying hydration and interactivity based on viewport and user intent, prioritizing critical UI, and even creating SSR-only components.Through practical examples, we’ll see how these use()-driven patterns can help us avoid common performance problems in heavy React pages: too much JavaScript, too much hydration work, and too many components competing for network and CPU before the user actually needs them.By the end of the talk, you’ll see use() not just as a data-fetching API, but as a new way to control when React components should load, render, and hydrate — helping us build faster pages and more intentional user experiences.
The Browser Is the Brain: Building Smart React UIs with In-Browser ML
Upcoming
The Browser Is the Brain: Building Smart React UIs with In-Browser ML
What if your React app could understand users without sending their data anywhere?Modern browsers can now run meaningful machine learning locally. This talk shows how to use in-browser ML to build React interfaces that personalize, adapt, and respond in real time, while staying fast, private, and predictable in production.
Mastering Next.js Cache Components
Upcoming
Mastering Next.js Cache Components
Next.js 16 introduced cache components, a fundamentally new approach to caching that replaces implicit behavior with explicit, composable control. In this talk, I'll build a dashboard from scratch to show you how cache components work in practice: how the static shell gets prerendered and served instantly from the edge, how 'use cache' caches expensive data on your schedule, and how Suspense streams dynamic content in real time, all in the same route. You'll see the three 'use cache' variants in action, learn the donut pattern for maximum performance, understand why generateStaticParams matters more than you think, and walk away with practical patterns for cache invalidation that work in production.
From Fiber to Async React
Upcoming
From Fiber to Async React
Almost a decade ago, React’s rendering algorithm was rebuilt, and with that it brought about new tools, ideas, and ways of building UI. But those tools arrived incrementally and were adopted in isolation, often framed as “optimizations” rather than part of a unified model. So are they truly independent ideas, or are they different expressions of the same underlying model made possible by the new rendering algorithm?Join us as we re-introduce "Async React" as the mental model for modern react and show how we can write more declarative code, embrace async-first as the default and let React handle the rest.
The Hidden Cost of Shared Frontend Code: Lessons From 8 Apps and One Monorepo
Upcoming
The Hidden Cost of Shared Frontend Code: Lessons From 8 Apps and One Monorepo
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. Even “safe” refactors required coordinating across teams, managing rollouts, and avoiding breaking changes in production systems we didn’t fully control.This talk goes beyond best practices to explore the real trade-offs of shared frontend architecture at scale. I’ll walk through concrete failures, decisions, and constraints we faced — and the strategies that actually worked: strict dependency contracts, opinionated API design, staged migrations, and clear ownership models.If you’re building or maintaining shared packages in a monorepo or multi-app ecosystem, this talk will help you avoid common pitfalls and make better architectural decisions — before they impact multiple teams at once.
The AI Call Is the Render: Server Components as the Intelligence Boundary
Upcoming
The AI Call Is the Render: Server Components as the Intelligence Boundary
Most React applications treat AI as a separate service: a backend calls an LLM, returns JSON, and a client component renders it. This works, but it misses something fundamental about how React Server Components actually model computation.RSCs do not just move rendering to the server. They make the server a first-class part of the React tree. And the server is exactly where AI inference belongs: close to data, streaming by design, and free from the browser's constraints.In this talk I'll show a concrete architecture where the AI call is the render. A Server Component reaches out to a language model, receives structured output, and streams typed React elements directly to the client with no extra API route, no serialization layer, and no client-side state for the AI response.We'll cover the happy path, the failure modes, and the real-world lessons from building this in production, including hallucination-resistant validation, Suspense boundaries for model latency, and the one architectural mistake that will destroy your Time-to-First-Byte.
Analysing and Optimising Web Apps with AI Agents: From Codebase to Infrastructure
Upcoming
Analysing and Optimising Web Apps with AI Agents: From Codebase to Infrastructure
Workshop
Jonas Herrmannsdörfer
Jonas Herrmannsdörfer
AI agents can do much more today than generate code. Used well, they can read code, inspect HTTP responses, analyze build logs, evaluate deployment metadata, and help systematically find performance, cost, and infrastructure issues.In this 3-hour workshop, we build a practical agent workflow for web applications. We start with an external audit of a running app, then analyse common issues in a Next.js codebase and connect the findings with infrastructure data such as logs, deployments, caching behaviour, and metrics. The Vercel CLI is used as a concrete example, but the concepts also apply to other platforms with a CLI or API, such as Cloudflare, Netlify, or AWS.Participants will learn how to create repeatable agent skills for audits and debugging, how to build safe read-only workflows, and how to structure results so they lead to concrete technical actions instead of vague recommendations.
Register
Human + AI Shared State Management: Extending Frontend Patterns Into Agentic Systems
Upcoming
Human + AI Shared State Management: Extending Frontend Patterns Into Agentic Systems
State management has traditionally focused on synchronizing user interactions, frontend state, and backend persistence. But AI agents introduce a new type of actor into modern applications: autonomous workflows that can read, execute, and modify application state alongside human users.In this session, we explore how familiar frontend state management concepts can evolve into shared full-stack architectures where both humans and AI agents collaborate on the same data model. Using examples from modern React applications, we will examine sandboxed agent execution with forked state snapshots, deterministic merge strategies, concurrent updates between users and agents, and techniques for making agent actions observable and debuggable.Rather than treating AI as an external API call, this talk presents agents as first-class participants in application state transitions. We will extend familiar concepts such as state stores, reducers, event streams, and optimistic updates beyond the frontend into backend orchestration systems that keep human and agent state consistent.Attendees will leave with practical architectural patterns for building collaborative human + AI applications using ideas they already know from modern frontend development.