Dominik Dorfmeister

Ankita Kulkarni

Most tutorials show you how to build a course platform. None of them show you what happens after you ship it.

This is the honest post-mortem of building and scaling nextjscourse.dev, a custom, production-ready platform built entirely with Next.js and React. No off the shelf LMS, just real users and a lot of hard lessons.

We’ll cover the architectural decisions that held up and the ones that didn’t. What data fetching strategy to pick and when, optimizing using core web vitals, caching and revalidation patterns that actually work for paywalled content, and the real tradeoffs between building vs. buying at each layer of the stack.

A real case study in what production actually looks like and proof that you can still ship something powerful without reaching for a third-party platform.

Mark Erikson

We all want software to run fast, and ""performance"" can include everything from network times to keyboard latency. But what about when you really do need Blazing Fast (TM) CPU speed from your code? How do you know what sections of your code are slow, _why_ it's slow, and how to make it faster?

Like writing code and debugging, performance optimization is a skill set that anyone can (and should!) learn. We'll look at key concepts and approaches for profiling and optimizing CPU-level code performance, using real-world examples based on my experience optimizing the widely-used Immer JS library.

You'll learn how to set up reliable benchmarks, capture profiles and interpret flame charts, identify hotspots in your code, and apply optimizations ranging from simple wins like local caching to larger architectural changes. These techniques can help any developer's code run faster!

Ferran Negre

In 2018, I stood on this stage and showed an app I built with React Native. It worked — but you could tell it wasn't quite native. Eight years later, the bridge is dead, the old architecture is gone, and I'm shipping three production apps solo that users can't distinguish from native.

This talk is an honest, opinionated walkthrough of what actually changed — from native navigation primitives and SwiftUI/Jetpack Compose in JSX, to CSS catching up with the web, to new libraries that simply couldn't exist on the old architecture. I'll show real screens from my apps, real before-and-after comparisons, and I'll be honest about what still needs work. No hype, no docs recap — just 10 years of React Native experience distilled into what matters.

Matheus Albuquerque

View transitions promise app-like fluidity on the web, but integrating them into real products isn’t always just about a few API calls—it’s a journey.

In this talk, I’ll share my story of adopting view transitions at work. We’ll discuss how browsers implement them (e.g., how snapshots are taken, how animation pseudo-elements are orchestrated, and how promises let you hook into the lifecycle). We’ll also explore how frameworks like Astro and React integrate view transitions into both SPA and MPA workflows.

Last but not least, we’ll discuss real-world patterns, gotchas, and lessons learned around edge cases, accessibility concerns, fallback strategies, and performance considerations.

Violina Popova

As React applications grow, asynchronous logic often becomes fragile. Multiple useEffect hooks, ad-hoc retries, loading flags, and scattered error handling can create race conditions, memory leaks, and difficult-to-test business logic.
This talk introduces Effect-TS, a type-safe approach to managing async workflows in React. Rather than diving into functional programming theory, it focuses on practical patterns for:
• separating effects from execution
• typed error channels that prevent runtime bugs
• declarative retries, cancellation, and parallel workflows
• avoiding race conditions during component unmounts
• integrating incrementally into existing React or Expo codebases
Attendees will leave with real-world strategies to make complex async logic predictable, testable, and maintainable in production React apps.

Faris Aziz

Frontend engineers can ship excellent UIs while knowing very little about availability, SLOs, or delivery metrics. Many teams are set up that way, and it works, right up until reliability issues, slow rollbacks, or missed incidents start limiting impact and trust.

This talk is about expanding the frontend role beyond the UI and into the system it runs inside. Not to turn frontend engineers into SREs, but to build enough systems awareness to make better tradeoffs. We’ll look at resilience as a delivery mindset, and how practices like atomic changes, trunk-based development, feature flags, and automated rollbacks directly influence availability and recovery, even when failures originate elsewhere.

We’ll connect these practices to real constraints like SLOs and DORA metrics, and show why failure tolerance is contextual, from regulated systems where mistakes are expensive to product environments where controlled failure is acceptable. The goal is simple: help frontend engineers understand where their work fits in the system, so they can ship faster without increasing risk, make safer changes, and increase their leverage within a team.

Kevin Maes

From UI state to data-loading, React developers have plenty of solutions for managing client-side state. But what happens when a user action kicks off a process that takes hours or days to complete? Where does that state live, and how does your UI stay connected to it?

A new wave of durable execution solutions is addressing exactly this: backend processes that persist long-running state, retry on failures, and survive continuous deployments without interruption. Built on lessons from Navion, an AI-native logistics company, this talk shows how React and Temporal work together in production to coordinate the automation and human oversight of thousands of delivery orders.

I'll demonstrate how React 19's server features wire directly to workflows by querying their state, sending data and commands to running processes, and surfacing errors to users. The benefits of durable execution will become clear and you'll take away a practical understanding of when to use its power and how to wire it into your React application.