Talks archive

Talks 2026

37 talks · Alicante 2026

Speakers on stage during the AI panel at Frontier Alicante 2026
Attendees networking on the terrace at Frontier Alicante 2026
Speakers and attendees posing together on stage at Frontier Alicante 2026
Daniel Afonso

React-Driven Development: Career Lessons from the Framework Wars

"No one uses what I built!"

"Why can't I get support to do this?"

"I don't even know why we're using that?"

"Why am I always the one doing everything?"

Sound familiar? The truth is, friction is ever-present in our careers — in our influence, processes, relationships, and even the code we ship. But we're rarely taught how to handle it.

Here's the fun fact: React's history is full of lessons in dealing with friction. From the early skepticism around JSX and the Virtual DOM to the chaos of Server Components, the React team has navigated many friction points you'll face: skeptical stakeholders, unclear messaging, delayed initiatives, and the challenge of getting buy-in.

So let's recap the highlights since its birth to the latest release, understand what React got right (and wrong), and extract practical takeaways you can apply to your career, team, and developer experience initiatives. Whether you're leading a team, building internal tools, or advocating for a technical decision, you'll leave with concrete strategies for driving change, building trust, and shipping initiatives that actually get adopted.

  • Daniel AfonsoPagerDuty
Matteo Collina

The New Node.js: Built-in Batteries and the Road Ahead

Not long ago, starting a Node.js project meant installing lots of packages just to handle environment variables, run tests, or use TypeScript. Now, those days are behind us, and 2026 is the time to make the switch.

Node.js is stronger than ever, but there’s still a big issue: many people keep using outdated versions with known security problems. We need to discuss the current LTS schedule and why you should switch to Node 26.

This session will cover both the roadmap and hands-on examples. You’ll see how much you can do with just Node.js and your chosen framework, often with far fewer extra packages. We’ll look at built-in TypeScript support that works right away, so you can write and run TypeScript without a build step. We’ll also cover testing with node:test and node:assert, built-in .env configuration, and native fetch powered by Undici for HTTP. Other topics include watch mode for development, node:sqlite for embedded databases, and the stable Permission System for better security.

  • Matteo Collina
Kateryna Porshnieva

Making your codebase AI-ready

For decades, we've optimized code to be read by humans — naming conventions, file structure, abstractions, documentation. All of it shaped by what helps a person understand the code and make changes safely. Now more and more code is written, reviewed, and navigated by AI, which doesn't have the same strengths or weaknesses we do.

This talk asks what good architecture looks like in the AI era, in a way that sets AI up to succeed. I'll share what we've learned leading this shift at Buffer — which traditional principles still hold, which need rethinking, and how to approach this transformation in an existing codebase.

  • Kateryna PorshnievaBuffer
Joel Arvidsson

Native o’clock: time to use the platform

Following years of converging, the native platforms look drastically different again – it’s time to leverage the biggest strength of React Native and make our users happier at the same time.

Instead of limiting ourselves to the lowest common denominator, this talk explains why and how to leverage the underlying platforms’ native components and APIs to build a better, faster and more accessible app.

It explores the differences between the iOS and Android platform SDKs, how the more recent SwiftUI and Jetpack Compose frameworks are a great but underutilized fit for React Native due to shared paradigm, and finally how to tap into them using either Nitro or Expo Modules.

  • Joel Arvidsson
Aurora Scharff

What RSCs can do in Next.js today

React server components have come a long way. Starting from what makes React components composable, self-contained and easy for AI agents to work with, Aurora shows how data fetching broke that composability and how server components, streaming with Suspense, caching and partial prefetching in Next.js bring it back. A live demo builds a page out of independent components that fetch their own data, with instant navigations and tooling designed for agents: the speed of the server with the feel of the client.

  • Aurora ScharffVercel
Mattia Manzati

Your simple frontend shares backend challenges

Frontend and backend are often treated as opposite worlds. But are they really? Modern frontend apps face many of the same challenges as backend systems: multiple tabs drifting out of sync, shared cache invalidation, coordinating a single source of truth, retries, optimistic updates, and stale data. In this talk, we’ll look at how everyday UI code increasingly becomes a coordination problem, and what we can learn from backend thinking to handle it better.

  • Mattia Manzati
Sara Vieira

Breakout Session: Building 3D Games in React

Video games! Now that I have your attention: yes, you can build real 3D games with the same React you use to render dropdowns and settings pages. To prove it, we'll build Arkanoid, the brick-breaking arcade classic, using React Three Fiber. Along the way we'll cover meshes, lights, and cameras, physics with Rapier and the postprocessing that makes everything glow. React can really do everything!

  • Sara Vieira
Łukasz Nowak

D[JS]

A lightning talk about making music with code: Łukasz uses the Web Audio API to create sounds and compose music right in the browser, in plain JavaScript.

  • Łukasz Nowak
Milica Drača

Building Schema-Driven Forms in React

Forms start small and get messy when there is no system. Milica builds a schema-driven form in React with Zod and React Hook Form: one centralised schema for fields, rules and the API payload, typed inputs and outputs, and a plain mapping function instead of a transform so that expensive work, such as uploading an image, does not run on every keystroke. She ends with a form generated from a config sent by the API, so the back end can change the form without touching form code.

  • Milica Drača
Krzysztof Kowalczyk

Improving frontend developer productivity in large React codebases

Kibana has around 14 million lines of code, and finding where a piece of UI lives can take a while. Krzysztof shows the small developer tool he built at Elastic: an inspect overlay that, with a click on any element, reads the React fiber tree to show the component name, its source file and its parents, and opens it in VS Code or Cursor. It saves time at scale and, in the age of agents, it is cheaper in tokens to find the component first and then prompt.

  • Krzysztof KowalczykElastic
Eduardo Aparicio Cardenes

From Isolation to Acceleration: Building the fastest payment platform on an iFrame

Extracting the payment experience of an online platform into an iframe that works in the web, Android and iOS sounded simple, until it launched in Brazil and blew through a 10 second performance budget. Eduardo explains how the team measured what customers really lived through and applied three principles for the critical path: remove what the customer does not need, move earlier what they do, and move out of runtime what does not have to happen there. Feature flags and pre-rendering took the P90 from 16 seconds to under three.

  • Eduardo Aparicio CardenesSuper
Sujit Pradhan

React Compiler: Goodbye useMemo? Rethinking React Performance

For years we have memoised everything in React with useMemo, useCallback and React.memo, and that optimisation code is accidental complexity with its own dependencies to get wrong. Sujit asks what happens if we do not have to, and shows a live demo of the same app with and without manual memoisation once the React Compiler is on. His advice: write new code simply and let the compiler do the clever part, migrate existing code carefully and measure, and optimise on purpose rather than by habit.

  • Sujit Pradhan
Marcel Kalveram

Monoliths Work — Until They Don’t

A ten-year-old front-end monolith with flaky tests, outdated tooling and a one-hour CI/CD pipeline cannot move fast, even with money in the bank. Marcel tells how his team extracted new features from the legacy app with Module Federation, with a host and remotes, modern tooling from day one and a monorepo to avoid the polyrepo trap. In a few months they shipped three features without touching the monolith, the flaky tests disappeared and the team's confidence and velocity came back.

  • Marcel Kalveram
Oana Gabriela Stroe

Redrawing the line between engineering and design

In a world where AI writes much of the code, being a builder takes good judgment, good taste and product sense. Oana, who leads the design chapter at Hubtype in Barcelona, shares five decisions to make a better product when you or your agents build a feature: from whether it is functional and reliable, to hierarchy and context, with real examples such as reorganising a navigation based on usage data. She also covers how to bring design into agents with Figma MCP, Code Connect and design skills, and why you should review your own output first.

  • Oana Gabriela StroeHubtype
Jakub Tkacz

How Expo Observe can help you improve your app

Many apps feel slow on real phones because we only test them in the office, on fast Wi-Fi. Jakub, from Expo, shows how Expo Observe gives you startup and navigation performance, network requests and error monitoring from your users' devices, tied to the build, the update and even the commit. With an agent looking at the data, he takes an app's time to interactive from five seconds to 200 milliseconds and finds a screen that is slow only for users in Spain.

  • Jakub Tkacz
Forbes Lindesay

Fun with streams

Streams are an excellent abstraction for handling real time events, and streaming data such as audio and LLM responses. This talk takes you through the key APIs of web streams, and provides some examples for how you can use them in your applications.

  • Forbes Lindesay
Erik Rasmussen

Ripple: the Good Parts of React, Svelte, and Solid

Throughout history, empires rise and fall. Throughout web development, frameworks rise and fall. In 2026, we are firmly in "late stage React", where young devs can't remember the world any other way, and older devs are keeping their eye on the horizon for what's next.

What if I told you there was a TypeScript-first UI framework created by a member of both the React _and_ Svelte core teams focused on fine-grained reactivity and rendering speed that will look instantly familiar to you?

I'd like to introduce you to Ripple, show you around its syntax and philosophy and stimulate your mind out of the Present and into the Future.

  • Erik Rasmussen
Kevin Maes

Beyond Client-Side State: React Meets Durable Execution

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.

  • Kevin MaesBlueFolders
Dominik Dorfmeister

Dead Code Shouldn’t Exist: How We Removed 28k Lines of Code, One Knip at a Time

Unused code costs more than it looks: developers read it, maintain it and keep it error-free, and in the age of AI it also eats tokens and bloats the context window. Dominik, from the design engineering team at Sentry, tells how they used Knip to remove over 28,000 lines of dead code (about 3% of the codebase) in more than 50 pull requests, with a live demo of the cleanup and the lessons learned: production mode, false positives with dynamic imports and require.context, and running Knip in CI so the cleanup never has to be repeated.

  • Dominik Dorfmeister
Ankita Kulkarni

Build. Scale. Teach: Architecting and Scaling a Production-Ready Modern Course Platform

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.

  • Ankita Kulkarni
Mark Erikson

How I Made Immer Twice as Fast: Performance Optimization in Practice

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!

  • Mark EriksonReplay
Matheus Albuquerque

Visual Continuity on the Web: My Journey With View Transitions

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.

  • Matheus AlbuquerqueMedallia
Faris Aziz

Building Resilient UIs with React

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.

  • Faris Aziz
Aileen Villanueva Lecuona

My AI-Driven React Workflow: Building Faster with Agents

Our jobs as developers are evolving fast. We’re working quicker than ever thanks to AI, but our role is shifting from just writing lines of code to orchestrating it. We steer the agents in the right direction, and at the end of the day, we are still the ones responsible for what actually gets shipped to production.

But how do you actually unlock this productivity boost? It’s not as simple as just dropping an agents.md file into your repo and hoping for the best. In large projects, context is everything, and tool overlap is a real headache.

In this talk, I’m opening up my laptop to show you my everyday React workflow sharing what I’ve learned from building enterprise apps with Spekit and internal platforms like BMAD, down to my personal side projects.

We’ll cover:

Context at Scale: Why big projects need more than basic prompts, and how to use tools like BMAD and Spec kit to give your agents the exact context they need.

Framework "Skills": How to leverage native features and MCPs from modern React frameworks so your AI understands your specific architecture.

Managing the Noise: You’ve got linters, GitHub Copilot suggestions, agent rules, and autonomous agents... how do you use them all together without them fighting each other?

Steering & Responsibility: Practical habits for guiding agents, reviewing their output, and making your day-to-day coding easier without breaking production.

  • Aileen Villanueva Lecuona
Ferran Negre

React Native is Native — Back at React Alicante, 8 Years Later

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.

  • Ferran NegreFitHero
Devlin Duldulao

Redwood SDK: React Server Components on the Edge, Simplified

React Server Components are not a framework but a React feature that needs bundler cooperation, and every framework implements them differently. Devlin compares the same page in Next.js, Waku and Redwood SDK, and then follows a request through Redwood SDK on a Cloudflare Worker: HTML rendered and streamed at the edge, little client JavaScript and a small RSC payload only when something needs interactivity. A simplified look at RSC on the edge, in lightning talk format.

  • Devlin DuldulaoInmeta
Hayk Yaghubyan

The React White Screen of Death: Detection, Recovery, and UX Strategies

A bug report that just says 'the page is white' is one of the worst you can get, and a blank screen tells the user nothing about whether their work is safe. Hayk follows what React does when nothing catches an error and shows how to recover: error boundaries at the root, route and feature levels working together, screens that keep the navigation and offer actions, and named states for loading, empty and error. The rule: ship the recovery path before you ship the failure.

  • Hayk Yaghubyancasavi GmbH
Milica Aleksic

Multiple Apps, Millions of Users: Scaling React Native in Production

Starting with one React Native app and ending with five portals, two teams and millions of users, Milica tells how the architecture at Novium evolved. When it all felt slow they profiled before rewriting, and found that the problem was not React Native but one shared piece that knew too much about every product. What they learned: share behavior that must stay the same, keep product decisions in small UI components, and give every shared piece a clear owner.

  • Milica Aleksic
César Alberca

Software Craftless: Writing Code That Would Make a Goat Vomit (React Edition)

A satirical talk on how to write code that would make a goat vomit. If nobody can read your code, nobody can fire you, and not even AI can replace you. César goes through very precise tips on unreadable components, impossible names and syncing state with effects, to show, by opposition, what good code looks like: a single source of truth, derived values and code that is easy to read and test. Includes a giveaway and a lot of laughs.

  • César Alberca
Shivay Lamba

Building AI-Powered React Apps with TanStack AI

TanStack AI is an open-source TypeScript toolkit to build AI-powered React apps without writing your own adapters for each model. Shivay shows how it works: server-sent events converted into messages by the useChat hook, fully typed tools, an agent loop strategy, validation of the user's input with Zod and custom skills, with a demo of an app that suggests what to buy for a day at the beach.

  • Shivay Lamba
Néstor López

Rspack and Module Federation: The modern path to distributed microfrontends

Rspack is a JavaScript bundler, Rsbuild is the build tool on top of it, and Module Federation lets you share code between applications at runtime. Néstor, from the Module Federation core team, explains how they relate and why federating at the bundler level is useful, with examples such as ByteDance, Netflix and PayPal combining apps built with different frameworks into one host. It also lets you change a version without building or deploying again.

  • Néstor LópezZephyr Cloud
Evangelia Mitsopoulou

Beyond Linting: Building an AI Code Reviewer Grounded in Architectural Mental Models

Measuring architecture is much harder than catching bugs. Evangelia shows how she built an AI code reviewer grounded in the mental models of her engineering academy: the curriculum rewritten as machine-readable patterns (principle, gold standard and signals) and an eval system with real pull requests labelled by hand. The first results, with 47 PRs across six exercises, show why you have to measure the output first, and why your teaching is your advantage.

  • Evangelia Mitsopoulou
Christopher Buecheler

You Are a Customer Success Engineer (or at least you should be!)

After 27 years in web development, Christopher became a customer success engineer at a startup, moved from the US to Paris and gave this, his first conference talk ever. His point: every engineer who builds something should talk to their customers. He explains how to find their pain points, turn skeptics into champions, collect feedback, communicate regularly and keep the whole product in sight, in a talk that is as honest as it is useful.

  • Christopher BuechelerEmbeddable
Violina Popova

Controlling Async Chaos in React with Effect-TS

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.

  • Violina PopovaClipMyHorse.TV
Aris Markogiannakis

React Security Odyssey: Sailing with CSP to Ithaca

Every React application sets sail toward its own Ithaca: production. But the waters of the modern web are filled with monsters.

The Sirens of XSS wait for one careless rendering decision. The Cyclops of injection attacks hunts for unguarded input. Trojan Horses disguised as third-party scripts may carry danger straight through your gates.

In this React Security Odyssey, we’ll navigate these threats using Content Security Policy (CSP) as our shield, while exploring practical defences against XSS, clickjacking, injection attacks, unsafe scripts, and insecure resource loading.

Through real-world examples, we’ll uncover common security mistakes and the patterns that help prevent them.

Production is our Ithaca. The monsters are real. Let’s make the journey secure.

  • Aris MarkogiannakisCityJS
Kitze

Next Level AI Engineering

Kitze closes the conference with a funny and very practical talk on the future of AI engineering, a follow-up to last year's move from vibe coding to vibe engineering. He shows how he works with a personal software factory: agents running on his own server with Proxmox containers, PM2 and Traefik for tidy dev URLs, several coding subscriptions and their limits, and a loop where one agent writes the code, another reviews it until they agree, a third tests the app by clicking through it, and the task merges itself.

  • KitzeSizzy

How AI is changing software development

An unplanned and very interesting debate came up between the talks: some of our speakers took the stage to discuss how AI is changing software development and our industry. Here it is.