Talks

Most developers can get a basic Express.js API running in an afternoon. The hard part is making it production-ready — and keeping it that way.

This talk covers the patterns I've settled on after building APIs that actually run under real load: route organization, middleware design, error handling, JWT authentication, request validation, and structured logging.

I'll also walk through graceful shutdown, rate limiting, and how I structure larger Express projects so they don't turn into a mess as they grow.

Whether you're starting fresh or trying to improve an existing API, this talk is a practical blueprint you can take and use.

MongoDB's flexible schema is one of its biggest strengths — and one of its biggest traps. Without intentional design, you end up with documents that are expensive to query and painful to maintain.

This talk is about designing schemas around the queries you actually run. We'll go through embedding versus referencing, handling one-to-many relationships at different scales, avoiding unbounded arrays, and building indexing strategies that hold up over time.

I'll also cover aggregation pipeline patterns and where denormalization makes sense, even when it feels wrong.

If you've ever wondered why your MongoDB queries are slower than expected, this talk will give you the mental models to figure it out.

Next.js has API routes built in — so why would you reach for a separate Express.js backend? Sometimes you shouldn't. But for apps with complex business logic, shared APIs across clients, or teams that need clear separation of concerns, a dedicated backend is often the right call.

This talk walks through how I structure full-stack apps that combine Next.js on the frontend with Express.js behind it. We'll cover monorepo setup, shared TypeScript types, CORS configuration, authentication across the split, and deployment patterns that work well for this architecture.

By the end, you'll have a clear picture of when to split and how to do it cleanly.

Automation is one of the most useful things a developer can build — and Node.js is genuinely great at it.

In this session I share how I approach automation projects from start to finish: scraping dynamic sites with Playwright, scheduling recurring tasks with node-cron, storing results in MongoDB, and making scripts resilient enough to run unattended in production.

I'll cover real examples I've built — price monitors, report generators, data sync tools — along with how I handle anti-bot detection, retries, and monitoring so I actually know when something breaks.

This talk is for developers who want to build things that keep working after they've shipped them.

JWT is everywhere, but so are bad JWT implementations. This talk cuts through the confusion and shows what secure JWT authentication actually looks like in a Node.js and Express application.

We'll go through the access and refresh token strategy, why httpOnly cookies matter for refresh tokens, how to implement token revocation without a full session store, and the security mistakes I see most often in the wild.

I'll build a complete auth flow from scratch during the talk — login, refresh, logout, and protecting routes — so you can see exactly how the pieces fit together.

If you've ever been unsure whether your JWT implementation is secure, this talk will give you clarity.

Users expect real-time features now — live notifications, chat, collaborative updates. Socket.io with Express makes this achievable without rebuilding your entire stack.

This talk walks through adding real-time functionality to an existing Express application. We'll cover rooms, namespaces, event design, and handling authentication so only the right users receive the right events.

I'll also go into scaling Socket.io with the Redis adapter and how to handle reconnections and missed events gracefully so the experience stays smooth even on flaky connections.

You'll leave with a practical approach for adding real-time features to any Node.js application.

Knowing how to build a Node.js app is only part of the job. Getting it deployed and keeping it running reliably is the other part — and it trips up a lot of developers.

This talk covers the deployment workflow I've settled on: Dockerizing the app, setting up CI/CD with GitHub Actions, using Nginx as a reverse proxy, managing environment variables properly, and monitoring with structured logs and uptime checks.

I'll also walk through zero-downtime deployments and how to roll back quickly when something goes wrong, because something always goes wrong eventually.

Whether you're on a VPS or a cloud platform, this talk will give you a practical foundation for shipping Node.js apps with confidence.

When you're maintaining a Next.js frontend and an Express backend together, keeping them in sync as the team grows is a real challenge. Monorepos help — but only if they're set up thoughtfully.

This talk covers how I structure fullstack JavaScript monorepos with Turborepo: shared TypeScript types, shared utilities, efficient build pipelines, and CI/CD setups that build only what changed.

I'll also cover the less obvious stuff: managing environment variables across packages, setting up Docker builds in a monorepo, and avoiding the common pitfalls that make monorepos more painful than helpful.

If you've been dealing with version drift or copy-pasting types between repos, this talk is for you.