Conference Talks
Ready-to-deliver presentations on React, Next.js, payments, and developer experience. Each talk can be customized for your audience.
Available Talks
Ready-to-deliver presentations for your event
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
What happens when 'just integrate Stripe' isn't enough? As platforms grow, payments turn from a simple integration into a complex web of gateways, compliance, and strategy conflicts. This talk is for anyone who's hit scaling pain. I'll walk through the hard lessons from moving millions through fragmented systems, and show how treating payments as orchestration, not a feature, can unlock real growth. No fluff, just the realities of building monetization systems that scale. 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.
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.
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.
Performance Without Memoization, The Atomic Design Approach
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.
Building Software That Heals as Fast as It Breaks
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.
Letting Go of Control, Leadership at 200 Miles an Hour
On a racetrack, the most dangerous moment is not full throttle or hard braking. It’s the neutral phase, the transition between the two. Apply pressure at the wrong time and the bike loses balance. Too much throttle and you high-side. Too much brake and you low-side. Leadership works the same way. As teams move faster, ship more often, and increasingly rely on automation and AI, the role of a leader shifts. You are no longer the one creating forward motion directly. Your job becomes managing pressure, when to accelerate, when to slow down, and when to stay neutral long enough for the system to stay stable. This talk uses motorsport as a mental model to explore modern engineering leadership. We’ll look at the balance between directive and enabling leadership, how to maintain quality without becoming a bottleneck, how accountability changes when work is delegated to people and tools, and how to lead teams operating at high speed without burning them out or losing control. This is a practical talk about restraint, timing, and judgment, and why knowing when to let go matters more than knowing how to push.
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.
Raycast and Chill, a gentle gateway into open source
Open source feels intimidating. Huge codebases, long contributor guides, noisy issue trackers, and pressure to grab a good first issue before someone else does. For many engineers, that friction is enough to never start. Raycast is a different entry point. If you write React or React Native, you already have the skills needed to build or contribute to a Raycast extension. The SDK keeps scope small, the feedback loop is fast, and maintainers are active and responsive. This talk shows how Raycast can act as a low stress gateway into open source. You will see how to build something useful quickly, how to contribute without drowning in context, and why starting small is often the most effective path to long term involvement.
React 19.2 in the Wild: Activities, Effects, and Performance in Practice
React 19.2 introduced new primitives for managing effects, background rendering, and performance, but most teams don’t adopt them straight from the release notes. Production apps carry constraints, legacy patterns, and performance debt that make change slower and riskier. This talk looks at React 19.2 in the wild by breaking down how typical UIs we build in real applications can evolve with the new APIs. We’ll look at how <Activity />, useEffectEvent, and cacheSignal change common approaches to state, rendering, and data handling, and how to start taking advantage of them to make everyday React apps feel smoother and more predictable.
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.
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.
Need a custom talk?
I can create tailored presentations for your specific audience and event format. Let's discuss what would work best.