Build it, then ship it.
Interactive sessions where participants learn by building. Available for conferences, corporate training, and bootcamps — full-day or half-day formats.
Nobody learns from slides alone
Hands-on learning
Build real projects during the session — guided exercises, working code by the end.
Small group format
Interactive sessions mean personalized attention and questions tackled as they come up.
Take-home materials
Code samples, exercises, and reference docs to keep building after the session ends.
Available workshops
Mastering Production-Grade Patterns with TanStack
For performance, scale, and effectiveness This is not a beginner TanStack Query workshop. This workshop focuses on proven, production-grade patterns for architecting data fetching with TanStack Query, designed for applications that care about performance, scale, and long-term maintainability. We’ll go beyond APIs and hooks and focus on how the fundamental concepts scale. You’ll see how the same core ideas work for apps with a few hundred users and for systems serving tens of millions of users, without rewriting your mental model every six months. The patterns in this workshop are battle-tested in real production environments and are designed to improve developer experience, reduce complexity, and make performance predictable. We’ll also briefly step back and look at TanStack as an ecosystem, showing where other TanStack libraries fit and how to think about them as part of a coherent system, while keeping the main focus firmly on TanStack Query. The workshop draws directly from experience implementing TanStack Query in real production applications, ranging from small products to platforms serving tens of millions of users. Expect concrete patterns, trade-offs, and failure modes. You don’t need prior TanStack Query experience, but this workshop assumes you’ve built real applications. You’ll leave with a clear, scalable mental model for architecting data fetching with TanStack, and patterns you can apply immediately.
Payments and Monetization at Scale for Frontend Engineers
Payments are often introduced as a simple Stripe integration. In practice, even small products quickly run into complexity around pricing, subscriptions, failures, and global users. Frontend engineers are usually closest to checkout and monetization, yet rarely get a clear foundation for how payments actually work. This workshop is a practical introduction to payments and monetization from a frontend and full-stack perspective. Using React and Next.js, we’ll start with the core payment concepts every engineer should understand, then gradually build toward real-world scenarios. You’ll learn how a payment flows from user intent to settlement, how common payment methods differ, and how to structure checkout and subscription flows safely in modern web apps. We’ll use Stripe as a concrete example, but focus on patterns rather than vendor-specific APIs. Along the way, we’ll introduce merchant of record concepts, pricing and subscription basics, and what changes when you sell internationally. You’ll also see how to handle loading and error states, asynchronous confirmations, and post-deployment safety in a way that keeps both users and revenue protected. By the end of the workshop, you’ll have a clear mental model of payments, understand how monetization fits into your frontend architecture, and feel confident building and evolving checkout flows without treating payments as a black box.
Real-World React: Designing Frontend Architectures That Survive Production
Most React workshops focus on building features. This one focuses on keeping them alive. In production, React applications fail in ways that local environments never show: partial outages, slow dependencies, silent errors, broken rollouts, and performance regressions that only appear under real traffic. This workshop is a practical, architecture-first walkthrough of how experienced teams design React systems that stay resilient, observable, and scalable long after the first release. We will explore how component architecture, reconciliation in practice, and runtime failure patterns shape performance and operability far more than memoization tricks or framework features. Using React and Next.js as shared reference points, we will work through concrete patterns for failure recovery, error containment, safe rollouts, and post-deployment confidence. This is a hands-on, experience-driven workshop based on real production constraints, tradeoffs, and lessons learned from operating large React applications at scale. Attendees will leave with a mental model for building frontend systems that can fail safely, recover quickly, and ship continuously without fear. Most of the workshop is framework and library-agnostic, but we'll use React and Next.js as our common ground for communication and examples. This is not an exhaustive masterclass; it's a conversation starter and experience share to jumpstart your journey toward battle-tested software architecture.
Areas I run deep sessions in
From production engineering to career growth — pick what fits your audience.
Next.js in production
App router, server components, performance budgets.
React Query patterns
Cache invalidation, suspense, infinite scroll.
Real-world architecture
Module boundaries, monorepo patterns, shared types.
Observability
Logging, tracing, what to measure when it breaks.
Resilient patterns
Retries, circuit breakers, graceful degradation.
Engineering leadership
Reviews, prioritisation, growing senior engineers.
SDLC best practices
Branching, CI/CD discipline, fast feedback loops.
Career growth
From mid to senior to staff — what actually moves the needle.
Follow my conference schedule
Find out when I'm speaking near you.
Need a custom workshop?
Tailored sessions for your team or event — pick a topic, tell me about your audience's level, and I'll build it for you.