Conference talks, tailored for your room.
Production stories on React, Next.js, payments, and developer experience — each adaptable to your audience's depth and time slot.
Available talks
Caching, Payloads, and Other Dark Arts: Optimizing UX in Suboptimal Conditions
This talk breaks down real world data fetching challenges at scale and how to solve them with modern patterns like the BFF layer, granular payload shaping, prefetching, and critical versus optimal queries. We walk through progressively improving an architecture that starts with five parallel client side requests against a bloated API, then move the work to a proxy handler, and finally to a fully optimized TanStack Query setup with server prefetching and resilient fallbacks. All demos were recorded on a long haul flight using in flight WiFi, showing how these patterns behave under real latency, unstable bandwidth, and failure conditions. The goal is to prove that these techniques are not academic. They directly affect reliability, performance, and user experience in harsh environments where debugging, caching strategy, and payload discipline make or break your product.
Orchestrating Millions Across the Globe: Reactive Payments at Scale
“Just integrate Stripe” works, until it doesn’t. As soon as a user-facing product accepts payments, whether one-time purchases, subscriptions, upgrades, or add-ons, payment flows begin to behave like distributed systems. Gateways, regions, retries, experiments, fallbacks, and partial failures all interact in ways that linear checkout flows were never designed to handle. This talk distills how to think about payments through the lens of reactivity. Instead of modeling payments as a sequence of steps, we’ll explore how treating them as reactive orchestration systems, driven by state changes and events, leads to architectures that are easier to extend, reason about, and recover under real-world conditions. Using concrete production examples, we'll walk through the technical lessons learned from operating high-volume, global payment flows and show how frontend payment orchestration becomes a first-class concern once products move beyond trivial checkout logic. While the examples use React, the underlying ideas apply to any frontend framework or library. The best part? I’ll end with a live demo of this running in production on Smallpdf, where we built and shipped our in-house reactive frontend orchestration system in React, now serving tens of millions of users worldwide.
Building Resilient UIs with React
Modern React applications are no longer just UI layers. They sit at the boundary of a distributed system, coordinating APIs, third-party services, feature flags, client-side caches, async rendering, and user-critical flows that can fail in several ways, some loud and others not so much. This talk looks at resilience from the frontend outward. Not in a “self-healing systems” sense, but in the practical sense of baking better guarantees into the way we design React applications, so they fail more predictably, recover more safely, and surface the right signals when things go wrong. Using real production lessons from Smallpdf, including a 35-day region-specific payment failure that went undetected while most metrics looked healthy, we’ll examine why frontend resilience is often less about preventing total outages and more about containing partial, conditional, and business-critical failures before they become expensive. We’ll explore how React architecture directly shapes recovery speed, debugging precision, and operational confidence, especially at scale. Along the way, we’ll cover the frontend as a distributed system boundary, why platform uptime does not equal successful user outcome, how to use component trees, Suspense boundaries, and error boundaries as failure-containment tools, and how feature flags can either improve safety or quietly multiply risk depending on how they are structured.
Engineering Without a Safety Net: Where It Works and Where It Hurts
Testing, monitoring, observability. They're rarely urgent, often skipped, and easy to dismiss when things are moving fast. But what's the real cost of deferring them, and how much can you actually get away with? This talk explores the tradeoffs of skipping traditional engineering practices in the name of speed, and what happens when you try to layer them in after a system has already scaled. It's not about dogma or checklists, it's about pragmatism, risk, and timing.
Reconciliation First, Performance Follows: Atomic Design for Predictable React Rendering
Most teams fight React performance with memoization band aids and prop drilling acrobatics. We obsess over useMemo and useCallback, sprinkle React.memo everywhere and hope for the best. Yet performance problems keep surfacing. The root issue is usually not a lack of memoization; it is a misunderstanding of component architecture. This talk dives into how React’s reconciliation works, and how combining it with Atomic Design principles gives you a natural performance model without escape hatches. By structuring components around stability boundaries and predictable render surfaces, you avoid unnecessary re-renders from the start and remove half the memo calls currently in your codebase. I will show real examples at scale, common reconciliation traps, measurable outcomes when refactoring with atomic boundaries and how to test and profile effectively. You will leave knowing where React pays attention, how to design with reconciliation in mind and why deleting memoization more often than not is in your favor.
The Hidden Battleground, Engineering High-Conversion Payment Experiences
For most products, the checkout is the most critical and fragile part of the funnel. It’s where traffic turns into revenue, where small UX regressions compound into large financial losses, and where system failures become immediately visible on the balance sheet. This talk explores how to build resilient, high-converting payment experiences as systems, not screens. Drawing on hundreds of A/B experiments run on tens of millions of users and lessons from operating a global subscription platform generating tens of millions in annual recurring revenue, we’ll look at how payment orchestration evolves as products scale across regions, currencies, and providers. We’ll cover how to design checkout UX that converts consistently even for low-frequency products, how to orchestrate multiple gateways without leaking complexity to the user, and how to test and monitor flows where failure tolerance is extremely low. Along the way, I’ll even show a shocking example where adding just two form inputs, implemented correctly, could cost over a million dollars in lost revenue. This is a practical talk from the trenches about why checkout is a hidden battleground, and how resilient payment engineering protects both conversion and growth.
I Made a Million-Dollar Mistake, Now What?
We’ve all shipped something that cost money. An AWS service is left running. A misconfigured webhook. Test keys in production. Small mistakes, varying blast radius. But what happens when a system that serves tens of millions of users per month starts leaking revenue without ringing any alarm bells? Not through a massive crash, those are the easy ones to notice. But through partial failures that look “healthy” in most dashboards. This talk is a case study of a 13-year-old, bootstrapped product that has processed billions of requests, generates tens of millions in annual revenue, and is operated by roughly 10 engineers across the frontend and backend. In 24 hours, on the frontend alone, we can potentially amass over 120,000 errors, generate more logs than we can afford to retain in Datadog for more than two weeks, and other quirks that come with sheer scale. Failures are rarely total. They are regional, conditional, asynchronous, and financially expensive. We will analyze real postmortems in which losses accumulated silently over weeks (one even 9 months). We will explore how architecture across the stack, from React boundaries to API contracts to observability pipelines, determines whether you detect risk early or explain it later. This is not a blame story. It is not a hero story. It is a systems story. Because at scale, software will break. The question is whether your architecture tells you fast enough that it is costing you money and forgives you along the way.
It Worked on My Machine: Debugging Without the Screenshot Olympics
Every developer has lived their own version of “it worked on my machine.” Mine involved a client who stayed after a CrossFit class so I could debug a broken payment flow with them, outdoors, on their laptop, armed with blurry WhatsApp screenshots and bug reports that made no sense. I even found myself explaining how to open the browser network tab to someone who’d never seen DevTools. In this talk, I’m bringing that same 2020 app back to life, a weekend React-and-Rails project held together by hope, to see how we’d tackle those same problems today. We’ll look at how modern full-stack session recordings and AI-assisted IDEs turn that chaos into context in a world where we now ship vibe-coded apps faster than ever.
Reverse-Engineering Seniority, From Bootcamp Grad to Staff Engineer in Four Years
I started my career without a CS degree, without an internship, and without a clear path in. I came from a coding bootcamp straight after high school, previously worked as a CrossFit instructor, and entered the industry already behind on paper. Within a few years, I became a Tech Lead and then an Engineering Manager at 22, working across multiple regions, cultures, and team setups, remote and in-person. This talk is not a success story highlight reel. It’s a breakdown of the hurdles, wrong assumptions, and tradeoffs that came with moving fast. Overall, it's the key lessons I learned when I was hell-bent on climbing the ladder. I’ll cover what actually mattered for promotions, what didn’t, how ageism stayed as a shadow I struggled to shake, and often, how I navigated credibility when I was younger than almost everyone I managed. I’ll talk about learning strategies that worked in practice, how I leveraged a non-traditional background instead of hiding it, and the mistakes I made by chasing titles too early. We’ll also look at seniority through a more reflective lens, what it really means, how it changes over time, and why many people feel stuck even when they are doing “everything right.” This talk is for people early in their career, people frustrated by slow growth, and people who want to move fast but not blindly. I’ll share what I wish I knew then, what I would do differently now, and how my perspective on ambition, leadership, and progress has fundamentally changed.
Moving the Needle in the Age of Infinite Tools
Tech organizations are shifting fast. Product engineering roles are rising, AI accelerates execution, and expectations around productivity and ownership are higher than ever. With powerful tools everywhere, the real challenge is ensuring our work actually moves the needle. In a world of intelligent IDEs, automated reviews, AI agents, and endless frameworks, the differentiator is not output, it is critical thinking, prioritization, and understanding effort versus impact. Modern engineering requires clarity about which problems matter, how to measure progress, and how to build feedback loops that separate real improvement from motion. This talk shares practical ways to quantify impact, align technical choices with product goals, and choose work that meaningfully advances outcomes, from features to technical debt.
Need something tailored?
If none of these fit your audience, I can build a new talk around your theme. Tell me what you're hoping to land — I reply within two days.