Talks 2025

Side projects are the best way to solve problems that big software will never cater for: the ones only you, your family or your community have. Starting from the psychology of dopamine, this talk looks at the three things that stop personal projects from shipping (procrastination, scope creep and not knowing how) and how to beat them with small concrete goals, hardcoded MVPs and AI-assisted coding, using a puppy-care app built with Expo and Expo Launch, which takes a GitHub repository to TestFlight.

Waku is a minimal React framework built for React Server Components from day one. Starting from the starter project, the talk covers file-based routing, static and dynamic rendering with getConfig, hot reloading of server components, deployment to Node.js, Vercel, Netlify or Cloudflare Workers, and routing features such as segments, groups and slices. It then explains the vision of a minimal, extensible core, where even the router is a library, and introduces waku-jotai, which brings Jotai client state to RSC with server-only atoms.

Handling async operations in UI components can be tricky—flickering pending states, inefficient state updates, and unstable user experiences are common issues. Building accessible UI components presents additional challenges, as meeting accessibility requirements often requires extra effort, which can add complexity to the development process.

In the context of the Next.js App Router, this session will demonstrate how React Server Components streamline data fetching, while other React 19 tools help manage mutations, loading states, and optimistic updates more effectively. We’ll combine these with Ariakit to simplify the process of building interactive, accessible UI components with less boilerplate. You’ll leave with practical strategies for managing async operations while ensuring a smooth, reliable user experience.

Have we been stuck in the same testing pain loops for years? Even though it might seem like it, we haven't! Even if AI is now writing our tests, many React developers have faced numerous challenges, from the unclarity of test classifications to the struggle of mocking, long-running integration tests, and shifting everything to E2E tests. Let's recap everything that has happened in the past years and look into the present to explore what 2025 will bring for testing in the React world around test runners, testing libraries, mocking, production practices, and AI-based tools.

Compilers have long been seen as one of the most complex topics in computer science. Nowadays, web frameworks are evolving from runtime libraries into optimizing compilers and reshaping how we build user interfaces. Different topics in front-end development—e.g. reactive programming—are now experiencing this era fueled by static-analysis-driven insights.

This talk will explore how modern UI compilers are redefining performance and developer experience. We’ll discuss how some compilers are designed and different open-source solutions—including the React Compiler, Million.js, Svelte, and Marko—, as well as enterprise apps, and the growing role of compilers in automating things.

By the end of the session, you'll probably be optimistic about a future where compilers understand our entire code and offload a huge part of our mental burden related to manual tasks!

It's easy to forget what the creators of React knew from the start: that React is not only for building web pages. Most of us have heard of React Native, that renders to native mobile components, but React doesn't have to render to "components" at all. There's React PDF to generate PDFs and Ink for building UI in the terminal.

At my company, we've built a way for developers to use React to build plugins for our webapp that render to our custom components, giving us full control over the UI design (the "how"), whilst giving the plugin developer full control over the UX (the "what").

In my talk, I'll explain what it's like to build a React renderer and reconciler, what they are and how to use them.

You refactor a component, and six months later it is legacy again. Drawing on stories such as picking React Static over Next.js and rewriting a custom SSR app twice, this lightning talk explains the rules of the refactoring loop and how to survive it: the Boy Scout rule, visible tech tasks, a 20% tech-debt budget and dedicated tech sprints.

Feature flags decouple deploy from release by changing app behaviour at runtime without redeploying. This lightning talk contrasts them with environment variables, covers progressive delivery, kill switches, A/B tests, targeting and load throttling, shares good practices like owners, expiry dates and cleanup, and closes with React tips: a provider and hook, safe defaults and avoiding flicker.

The best components come from engineers and designers working together. This lightning talk shares how a design system team moved from design-first to system-first: joining design reviews early, building a shared vocabulary, adopting designer-owned design tokens, letting designers ship token changes to the repository themselves, and investing in the trust that makes collaboration work.

When a React Native and Expo tracking app for a motorcycle navigation challenge lost all signal in the Pyrenees, retries were not enough. This lightning talk introduces the seven ideals of local-first software and the path from a server-bound app to Zustand with AsyncStorage, a failed homemade Yjs sync and finally TinyBase.

MCP servers let AI assistants work with the tools front-end teams already use. This lightning talk shows Playwright tests generated from a prompt, Figma frames turned into React components and Storybook stories through the Figma MCP server, step-by-step workflow prompts for repetitive work, and better output from Figma variants, properties, variables and Code Connect.

Vibe coding can be a learning tool rather than a shortcut. This lightning talk offers strategies for deepening React knowledge with AI: start small with state and events, compare useState, useReducer and Context, use AI as a mirror to refactor messy code into custom hooks, build utilities before reaching for npm, then turn AI off and debug alone.

Four years of growing a startup's React app taught some hard lessons. This lightning talk covers wrapping third-party libraries behind proxies (which made replacing React Beautiful DnD painless), analytics adapters, extracting a component library too late, a Vite additionalData setting that duplicated CSS thousands of times, chunk errors after deploys and a bug-squashing leaderboard.

React is powerful, but filtering thousands of elements efficiently can be a performance bottleneck. Re-renders and complex JavaScript logic often seem unavoidable. We're going to throw out the rule book and achieve blazing-fast filtering with just CSS. Zero re-renders of the list, and without even needing a complex search algorithm.

Join me for a live coding demonstration where we build a high-performance search feature using only CSS. We'll employ some creative and unconventional techniques, using CSS in all the ways they always told us not to.

Prepare to have your assumptions about what's possible with CSS in React challenged, and to discover how a little outside-the-box thinking can lead to significant performance gains and simplified code.

Hidden features are small, deliberate surprises that reward curiosity, and React's conditional rendering makes them simple to build. After classics like Chrome's offline dinosaur and Google's barrel roll, this lightning talk builds map Easter eggs with React Leaflet, such as golden-hour spots and AI-generated fun facts on zoom, and proposes the SECRET framework for designing them.

Were you born as a graph node in a complex tree structure? For millions of people exploring their family history, that’s exactly what it looks like. In this talk, we’ll dive into GEDCOM—the standardized format that makes it possible to collect, share, and interoperate genealogical data across software platforms.

We’ll explore how this tree-shaped data structure lends itself beautifully to web development, from parsing and visualization to creative coding. Whether you’re into data viz, generative art, or just love building tools that make information more human, you’ll come away with ideas for transforming your own family history into rich, personal JavaScript experiences.

React has come a long way since its release in 2013 - from skepticism and surprise, to the most widely used UI library with the largest ecosystem. Today, there's an uneasy mixture of excitement over React's latest features, and community confusion over the goals and future directions of the React team. Why has React pivoted from being "just a view library" to a full-stack system? What's driving the React team's emphasis on using "frameworks" for projects? How will these directions affect React's existing capabilities?

We'll look back at the history of React's development to understand the major influences that have shaped its design. From there, we'll dig into the specific reasons for React's recent features and tool recommendations. Finally, we'll address some frequently expressed concerns about where React is headed and how that will impact existing and future React apps.

Every major React API, from hooks to Suspense to Server Components, has made hard problems more declarative and composable. After tracing that thread through React's history, this talk live-codes a video player app to show the next steps: the Activity component, stable in React 19.2, which keeps hidden UI such as a sidebar search mounted with its state while deprioritising its rendering, and React's still-unstable view transition support, which replaces imperative startViewTransition code with declarative animations.

Design systems break like sand dollars when teams hardcode values. This lightning talk shows how typing design tokens generated from Figma variables with Style Dictionary catches misspelled keys and drift at compile time, and how TypeScript type aliases can restrict props per variant, such as a card versus an alert, to prevent component misuse.

JavaScript Generators are often underrated, but they offer a powerful API that can unlock a variety of useful and creative patterns. In this talk, we'll explore how Generators can be leveraged to build fully type-safe APIs for both backend and frontend applications, ensuring strong typing throughout. Along the way, we'll also dive into some fun and experimental uses to demonstrate their flexibility and power. By the end of this session, you'll walk away with at least one new use case for incorporating Generators into your own APIs, while enjoying the benefits of full type safety.

At some point, we all think we know React—until we have to explain it to someone else.

I started creating React content to help other developers, but what I didn’t expect was how much it would change the way I approach building React apps. Breaking down concepts for others made me question my own assumptions, rethink patterns I had taken for granted, and spot issues in my own code that I had never noticed before.

In this talk, I’ll share:

1- The biggest React mistakes I only caught because I had to explain them

2- How content creation helped me write better, more maintainable React components

3- Why “learning in public” is the ultimate hack for improving your debugging skills

This isn’t just a talk about teaching—it’s about how explaining React forced me to build smarter, more scalable applications. Whether you're leading a team or optimizing complex React projects, this session will challenge the way you think about React development—and why sharing your knowledge might be the missing piece in your growth as a senior engineer.

A sequel to a 2018 talk about hype-driven frontend development, now with AI in the title. Between jokes about grifters and web platform features that never quite ship, it looks at what vibe coding really means, why LLMs write React so well, and a sceptical agentic workflow used to build around twenty apps in a year. It also explains why vibe coding disappoints some developers, from degraded models and cheap tools to buzzword overload, and when not caring about the code is fine.

Small, regular diffs make code easier to change. Inspired by the Zen idea of right speech, this lightning talk proposes three questions to ask your code: what is your purpose, do I understand you, and are you telling the truth. Examples include flattening nested conditions, lumping and splitting, explicit units, descriptive test IDs and honest TypeScript types.

Changing an email footer should not mean searching a monolith, a new service and Mailgun templates. This lightning talk shows how React Email turns emails into reusable React components rendered to HTML and plain text, with a preview server offering mobile view, source, compatibility linting, spam checks and test sends.

End-to-end tests get hard beyond the happy path. This lightning talk argues for covering business-critical flows such as multi-factor authentication, fixes a flaky Playwright test live with web-first assertions, explains the polling and actionability checks behind them, and discusses speed: parallel workers, Amdahl's law, app performance and deleting tests.

Deploying is a valuable skill for front-end developers, and Docker keeps you portable across cloud providers. This lightning talk explains images, containers and registries, walks through a minimal Dockerfile for a React Router app line by line, covers building for linux/amd64 on Apple silicon, and runs the image on Google Cloud Run.

Manual memoization with useMemo, useCallback and React.memo is easy to get wrong. Using an Expo app, this lightning talk shows the React Compiler in action: spotting re-renders with React DevTools, checking compatibility, adding the ESLint and Babel plugins, opting out per component, library pitfalls such as MobX, and the compiler playground's internals.

Browser extensions are just JavaScript, so you can build your own developer tools. This lightning talk builds a Chrome extension for managing cookies with a React UI bundled by Vite, uses an adapter pattern to develop it outside the extension, and combines content scripts with Testing Library to click through long multi-step forms automatically.

Voice messages in a web app looked like a two-week job with MediaRecorder. This lightning talk follows the real story: browser-specific recording and playback formats, in-browser conversion with ffmpeg.wasm in a web worker, bundler and cross-origin worker issues, shrinking the module from 11.3 MB to 900 KB, and why conversion finally moved to the back end.

Testing React Native apps has always meant choosing between speed and realism. Jest is fast and familiar, but it runs in Node.js, detached from native modules and runtime quirks. E2E frameworks bring realism but are slow and heavy to maintain. This talk introduces React Native Harness, which runs tests directly on the device with nothing mocked by default. You keep the Jest-style DX (describe/it, hooks, selective mocking) while getting access to real native modules - without rebuilding the app. I’ll cover how it works with Metro, show examples of testing complex native integrations, and explain how teams can get unit-test speed with near E2E realism.

Building cross-platform mobile and desktop apps in React Native is rising. We have seen that the current ecosystem is closing the gap towards Web-APIs. It is increasingly becoming feasible to build performant and truly universal apps and libraries. The latest advancement is the ability to execute WASM (WebAssembly) directly in a React Native app.

This talk covers a naive approach to implementing a native module for React Native, exposing WebAssembly runtime: Wasmer, which initially turns out to be really slow, mainly because of the restriction on iOS devices that apps are not allowed to perform just-in-time compilation on devices. This however is balanced with the React Native platform’s ability to run ahead-of-time compiled native code and the current solution, built and maintained by Callstack, uses wasm2c to build native modules for React Native.

This capability to run Wasm in React Native unlocks a lot of interesting use-cases to bring highly performant, secure applications usecases with low memory, size footprint of WebAssembly such as machine learning model inference, running C++ code directly in React native applications and unlocks businesses to leverage a powerful technology within their React native applications

Small animations can make UIs more delightful and improve user experience. In this talk, we’ll explore how to add these animations to your React apps, using everything from simple CSS transitions to more complex spring-based motion.

We'll walk through practical examples to show how these animations can enhance user experience without getting in the way. Plus, we'll discuss how to keep them running smoothly and make sure they're accessible to everyone.