Name: React Day Berlin 2026
Start: 2026-12-04T07:00:00.000Z
End: 2026-12-07T19:00:00.000Z

Seungho Park

Aleksei Podgaev

Lera

Karyna Bunta

Houda Mouttalib

Shubh

Hunor Márton Borbély

Filip Michalowski

Michael Geiss

Boris Karaivanov

khouchane Mahmoud

Pascal Lemmen

Vitor Barbosa

Stavros

Arash Sarfehjou

SKOLZ

Fathima Fasna

Emilie Follin

Martin Asenov Mladenov

Anastasia Tikhonova

Shivam Arora

Victor Jolissaint

Pavel Petrov

Maria-Fontica Marinescu

Jan Biasi

Adrian Williams

Amy Rae Som

Nicolas Schaber

eran

Alexander Hartvig

Aziz Shahhuseynov

Yakovlev Eugen

Alireza

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.

Goodbye Slop; Welcome Determinism

David Khourshid

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.

Taste: How React Leads to AI

Tejas Kumar

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.

Modern React Architecture

Brad Westfall

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!

It Depends: The Final and Honest Take On Client-Side AI

Nico Martin

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.

Building a Rich Text Editor in React Native

Rubén Sospedra

<div>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.</div><div> </div><div>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.</div><div> </div><div>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.</div><div> </div><div>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.</div>

Ship a Next.js App with Claude Code

Maurice de Beijer

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.

How Not to Use Tanstack Query

Neciu Dan

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 &lt;Activity /&gt; 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.

Modernizing Your React App: Compiler, useEffectEvent, Activity & Friends

Vitor Alencar

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.

The Fourth Platform: How Vega Got Us Surprisingly Close to "Write Once, Run Everywhere"

Bogdan Plieshka

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.

Most Engineering Interviews Are Broken: Here's What Actually Matters in the AI Era

Dennis Nerush

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.

Claude Code: Black Belt

Pawel Sawicki

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.

How I Brought React Into a Preact Form Engine: A Production Bridge Pattern

Saman Abaasi

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.

Transform Your React App Into an MCP App. Rebuilding UI for AI Agents.

Misha Kazakov

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?

React Compiler: Two Years in Review

Sascha Becker

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.

Change Is Only Good When Measured: Building Confidence Through Experimentation

Fadila Fidina

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.

The Code Isn't Precious: What Every Staff Engineer Figured Out That You Haven't Yet

Scott Batson

React Day Berlin

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.

React Day Berlin 2026

FocusReactive

Hygraph

Sentry

Porsche Digital

Grammarly

Sentry is essential for monitoring application code quality. From Error tracking to Performance monitoring, developers can see clearer, solve quicker, and learn continuously about their applications — from frontend to backend.&nbsp;

Porsche Digital is the technology unit of Porsche AG. We offer solutions that enrich the digital lives of our customers in and around the car.

Porsche Digital is the technology unit of Porsche AG

The world’s leading AI assistant for communication and productivity, trusted by over 30 million people and more than 70,000 professional teams.

FocusReactive is an&nbsp;<meta charset="utf-8" id="isPasted">engineering-led <a href="https://focusreactive.com/" target="_blank" rel="noopener noreferrer">Headless CMS Development Company</a>&nbsp;and&nbsp;<a href="https://focusreactive.com/next-js-expert-agency/">NextJS&nbsp;development experts</a>. Independent partners of Payload CMS, Sanity, Storyblok, Vercel and Shopify. Delivering&nbsp;<meta charset="utf-8" id="isPasted">Composable content platforms built for AI SEO, growing teams, and marketing velocity.