December 4 - 7, 2026
React Day Berlin
Berlin & Online

React Day Berlin 2026

Build apps, not walls

Full remote ticket included with Multipass.
Take part in the exploration of the React universe! Focusing on in-depth talks, hands-on workshops, and developing new opportunities, the React Day Berlin conference provides space for everyone to make friends and collaborate on stellar apps.
Goodbye Slop; Welcome Determinism
Upcoming
Goodbye Slop; Welcome Determinism
Vibe coding feels productive until you have to maintain it. Behind the agent "thinking..." you ignore and the code you never opened lies a growing pile of wasted tokens, nondeterministic behavior, and compounding errors hiding in plain sight.
This talk pushes back on the status quo: elaborate agent architectures, "prompting astrology", overnight automation loops burning through context windows and credit cards. We'll look at why determinism, state machines, and explicit guardrails aren't "old-school"... they're the only sustainable way forward.
We'll look at why vibe coding compounds technical debt faster than any era before it, and how modeling behavior explicitly lets you ship AI features you actually understand, maintain, and trust.
Taste: How React Leads to AI
Upcoming
Taste: How React Leads to AI
We've entered the era of "just add AI." Slap a prompt box on it, ship it, call it intelligent. But the products people love don't feel like AI demos. They feel obvious, fast, and considered. They have taste. Taste isn't subjective fluff. It's the difference between a streaming response that renders progressively and one that dumps text in a single repaint. It's choosing to compose rich, interactive UI instead of defaulting to a chat window. In this code-heavy session, we'll explore what taste actually means when building with AI: performance patterns, rendering decisions, and the product instincts that separate forgettable AI wrappers from tools people reach for every day.
Life After EAA: Maintaining Accessibility at Scale
Upcoming
Life After EAA: Maintaining Accessibility at Scale
The European Accessibility Act (EAA) is now the new normal, but the real work for web developers is often just beginning. As we are now in 2026, organizations across Europe are trying to find a way to build new features that are complying, and stay compliant to the WCAG guidelines.

In this session, we’ll go beyond the basics of EAA compliance to explore what it means to involve accessibility into every stage of the development lifecycle. We’ll cover advanced accessibility techniques, tools, and automation practices that help you integrate accessibility into CI/CD pipelines.

Through live demonstrations, you’ll see how to apply WCAG 2.1 standards using modern frameworks, test accessibility with tools like axe-core and Playwright, and fix common accessibility pitfalls developers still face.

By the end, you’ll know how to build, test, and maintain accessible web applications that stay compliant and user-friendly.
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
It Depends: The Final and Honest Take On Client-Side AI
Upcoming
It Depends: The Final and Honest Take On Client-Side AI
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. We'll cover the technical foundations, examine real-world use cases, and compare the trade-offs: privacy vs. performance, small models vs. big capabilities, client vs. server. Which tasks belong in the browser, and which belong in the cloud? It depends!
Don't Panic! React Security After 2025
Upcoming
Don't Panic! React Security After 2025
"Where we're going, we don't need roads"... but we absolutely need better security. The 2025 incident caught us off guard because we had forgotten past lessons. In this talk, we revisit the evolution of threats, moving from the "XSS Hell" of 2013 to the intricate data leaks of the Server Component era.

We will break down exactly what happens when the boundary between server and client dissolves. We will discover when React still has our backs and when we’re the last line of defence. Instead of waiting for a crash, we will focus on prevention, using a "Shift Left" approach to find bugs early. We will implement concrete patterns like React Taint APIs and Defense in Depth. Join us to build a full toolkit and ensure history doesn't repeat itself in your application.
Building a Rich Text Editor in React Native
Upcoming
Building a Rich Text Editor in React Native
Rich text editing on the web is a solved problem. On mobile, it's a battlefield. At Digg, we built a rich text editor in React Native anyway. This talk covers what we built, what broke, and the one architectural decision that made everything else possible: a universal content format that every platform, from the editor to the backend to moderation, agrees on. You'll walk away with a practical framework for designing cross-platform content formats, useful well beyond rich text for any unified system.
Ship a Next.js App with Claude Code
Nov 19, 15:00
Ship a Next.js App with Claude Code
Workshop
Maurice de Beijer
Maurice de Beijer
Join us for a hands-on workshop built for developers who want to move from idea to working software faster, using Claude Code, Anthropic's agentic coding tool. Unlike a typical autocomplete-style assistant, Claude Code lives in your terminal, IDE, or desktop app, reads and understands your entire codebase, and can take direct action: editing files, running commands, and handling git workflows, all through natural language.
In this workshop, you'll initialize a Next.js project from scratch and use Claude Code to plan, build, and iterate on a real, working application. You'll set up a `CLAUDE.md` file to give Claude persistent project context and conventions, so you're not repeating yourself in every prompt, and use Plan Mode to review an agent's approach before it touches any code, keeping you in control of multi-step changes. Along the way, you'll write effective prompts, delegate multi-step coding tasks, and let Claude Code handle the repetitive work of scaffolding, wiring up components, and debugging, so you can focus on product decisions and architecture instead of boilerplate.
By the end of the session, you'll have shipped a functioning Next.js application and gained a practical workflow for using Claude Code on your own projects, whether you're prototyping quickly or working within an existing codebase.
No prior experience with Claude Code is required. Some familiarity with React or Next.js is helpful but not essential; we'll cover what you need to know as we go.
Register
How Not to Use Tanstack Query
Upcoming
How Not to Use Tanstack Query
The promise of TanStack Query is enticing: "Delete your global state management and let the cache handle it." For many teams, this works—until it doesn't. While building a highly interactive, multi-user Kanban platform, we took this advice to the extreme. We bypassed traditional state management entirely, treating our backend as the "Single Source of Truth" for every UI interaction.It worked beautifully in development. But as we scaled to hundreds of concurrent users, our "simple" architecture turned into a self-inflicted DDoS attack on our own database.In this talk, we’ll go under the hood of TanStack Query to explore why the "Invalidate and Refetch" pattern fails in high-interaction environments. We will break down the architectural shift from reactive refetching to Optimistic UI, discuss the nuances of managing granular query keys, and define the clear boundary where Server State ends and Client State must begin. You’ll leave with a blueprint for building collaborative, high-performance UIs that are kind to your infrastructure.
Modernizing Your React App: Compiler, useEffectEvent, Activity & Friends
Upcoming
Modernizing Your React App: Compiler, useEffectEvent, Activity & Friends
React has changed a lot in the last year: React 19, 19.1 and now 19.2 brought a stable React Compiler, new hooks like useEffectEvent, the <Activity /> API, and better SSR primitives such as Partial Pre rendering. And more.
In this talk we’ll take a demo React app that’s full of effects, memoization and “old school” patterns, and modernize it step by step.
The Fourth Platform: How Vega Got Us Surprisingly Close to "Write Once, Run Everywhere"
Upcoming
The Fourth Platform: How Vega Got Us Surprisingly Close to "Write Once, Run Everywhere"
Zattoo has shipped streaming apps for over two decades, adding platforms one by one: Web in React, Android in Kotlin, Apple in Swift. Every new platform multiplied the work instead of extending it. The same feature built three times, in three stacks, by three siloed teams.

Then Amazon invited us to build for Vega, their new Linux-based OS where React Native is the primary UI framework, not an add-on. That became our catalyst to rethink everything: one React Native codebase across Web, Android TV, Apple TV, and Vega, held together by build-time overrides instead of runtime branches, organized by product domain instead of by platform.

This is the honest story of that migration. What carried over unchanged, what cost us sleepless nights with the Metro resolver, why Vega and Web turned out closer than they look, and where the React Native ecosystem still treats "iOS and Android" as the whole world when it isn't. A year of production data later, the surprises landed on the side of less work, not more.
Most Engineering Interviews Are Broken: Here's What Actually Matters in the AI Era
Upcoming
Most Engineering Interviews Are Broken: Here's What Actually Matters in the AI Era
AI has fundamentally changed how engineers work, but most hiring processes haven't changed at all.

Coding assistants can generate solutions in seconds. System design answers can be refined with prompts. Candidates walk into interviews with powerful AI tools at their side. Yet many companies are still evaluating engineers as if AI didn't exist.

So how do you actually assess engineering ability in this new reality?

After interviewing hundreds of engineers at Elementor, I redesigned my hiring process for the AI era. Instead of trying to prevent candidates from using AI, I changed what we evaluate. Today we test how engineers think, how they collaborate with AI, and how they apply judgment when AI-generated solutions are incomplete, incorrect, or misleading.

In this talk, I'll share what changed in our hiring process and what actually works in practice:
how we evaluate coding ability when AI is involved, which system design questions reveal AI orchestration skills, and what behavioral signals distinguish high-impact engineers from candidates who rely on AI to mask gaps.

Whether you're hiring engineers, preparing for interviews, or leading an engineering organization, you'll leave with a practical framework for evaluating engineering talent in the AI era.
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
If React Can Run 120 FPS GTA Vice City, It Can Run Anything
Upcoming
If React Can Run 120 FPS GTA Vice City, It Can Run Anything
If React can orchestrate an open-world 3D C++ game engine at a locked 120 FPS without dropping a single frame, it can handle your heaviest web workload. In this technical case study, we deconstruct how we ported GTA Vice City to WebAssembly and offloaded execution entirely to a background Web Worker. Learn how we bridged compiled C++ with React using SharedArrayBuffer, bypassed traditional Virtual DOM bottlenecks using ref-based micro-updates, and unlocked true off-main-thread UI architecture. You’ll leave with a battle-tested blueprint to make any React application virtually immune to thread freezing and input lag.
Transform Your React App Into an MCP App. Rebuilding UI for AI Agents.
Upcoming
Transform Your React App Into an MCP App. Rebuilding UI for AI Agents.
Workshop
Misha Kazakov
Misha Kazakov
Your UI already knows how to fetch data, submit forms, and navigate - so why are AI agents still scraping your DOM? In this workshop you'll turn your React app into something AI agents can talk to directly - an MCP app.

WebMCP is an emerging browser API protocol that lets web applications expose structured MCP tools directly to AI agents via navigator.modelContext. Instead of agents reverse-engineering your UI, they discover typed, documented functions - complete with JSON Schema inputs and structured responses. Basically, an MCP server running inside your web page.

In this hands-on workshop, we'll take a real React application with GraphQL data fetching and progressively transform it into an agent-ready MCP app. You'll learn how to identify which parts of your UI to expose as tools, architect a clean WebMCP layer that doesn't pollute your existing codebase, and add imperative API calls that agents can invoke on demand. We'll cover the spec, the practical patterns, and the gotchas - and you'll leave with a working implementation you can apply to your own apps.

No AI background required. If you build web apps, this is for you.
Register
How I Brought React Into a Preact Form Engine: A Production Bridge Pattern
Upcoming
How I Brought React Into a Preact Form Engine: A Production Bridge Pattern
In my work at MTN Irancell, we are building a Camunda-based workflow platform on top of bpmn-io Form-JS, a form engine that is rendered in Preact. The first time I had to bring a React component inside that Preact tree, it took me 2 weeks. I faced the famous "h is undefined" error one hundred times, two copies of React in memory, hooks failing, and re-render fights between Preact and React owning the same DOM. In this talk I will show the bridge I designed to solve all of this in production, with a live demo on stage where I mount a React component inside a Preact form engine in front of you.
React Compiler: Two Years in Review
Upcoming
React Compiler: Two Years in Review
React Compiler entered public beta alongside React 19 at the end of 2024 and reached 1.0 in October 2025. So how did it go two years after the hype?
Change Is Only Good When Measured: Building Confidence Through Experimentation
Upcoming
Change Is Only Good When Measured: Building Confidence Through Experimentation
Shipping a new feature is easy. Knowing if it actually improved anything? That's the hard part.

In production React applications, small UI changes can have a big impact on user behaviour. A new form, validation change, onboarding step, checkout flow, or performance improvement might reduce friction - or quietly make the experience worse.

Many teams still ship these changes based on intuition rather than evidence. Without measurement, it is impossible to know whether users succeeded more often, where they dropped off, or whether the change created unintended consequences.

This talk makes the case that experimentation is part of frontend engineering. Engineers are not only responsible for building the interface; we also help define what success looks like, add the instrumentation that makes behaviour visible, and release changes in a way that lets teams learn safely.

In this talk, we’ll walk through the experimentation lifecycle from a React engineering perspective: forming a hypothesis, defining success and guardrail metrics, instrumenting meaningful user behaviour, gathering data through feature flags or staged rollouts, and learning from the results.

Attendees will leave with a practical framework for embedding experimentation into React feature delivery, so teams can build confidence in the true impact of what they ship.
The Code Isn't Precious: What Every Staff Engineer Figured Out That You Haven't Yet
Upcoming
The Code Isn't Precious: What Every Staff Engineer Figured Out That You Haven't Yet
The engineers who make it to staff level aren't the ones who wrote the cleverest code. They're the ones who figured out that code was never the point.

Most of us learn this too late — after burning hours on solutions no one asked for, defending implementations no one remembers, wondering why technical excellence isn't translating into career growth.

Agentic AI just made this lesson impossible to ignore. But for engineers feeling anxious about that, there's good news: what actually drives growth at every level — senior, staff, and beyond — has always been more human than technical. How you communicate. How you understand a problem before you solve it. How clearly you can articulate what kind of engineer you are.
Scott Batson (Staff Engineer at Medium, with 15 years building at Netflix, PBS NewsHour, and beyond) makes the case that the engineers thriving in the agentic era were already thinking this way. This talk is about getting there.
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 UI interactions, frontend stores, 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 frontend state management concepts can evolve into shared full-stack architectures where both humans and AI agents collaborate on the same data model. Using Angular-based application examples, we will examine sandboxed agent execution with forked state snapshots, deterministic merge strategies, concurrent updates between users and agents, and observable agent actions.

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 stores, signals, reducers, and event streams 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 FE developers already know.