Methodologies, not tutorials

Engineering playbooks I actually use

These are the sequences I reach for when a real project is on the line. Each playbook is a methodology, not a tutorial. I have used every one of these in production work, and I keep them here so I can hand them to a client, a future hire, or the version of me who will forget this in six months.

17 playbooks120 phases total9 categoriesBattle tested

17

Playbooks

Step by step, no theory dump

120

Total steps

Across every playbook

80 min

Average duration

Per playbook end to end

9

Categories

Auth, AI, DevOps, more

Featured playbooks

Start here if you are new

Authenticationintermediate

Setting Up Authentication with Next.js

Authentication is the part of an app that has to be boring. This is the exact sequence I follow to bolt secure auth onto a Next.js project without inviting weird edge cases six months later. It covers provider choice, database design, session handling, route protection, and the small UI details that decide whether a login flow feels trustworthy or sketchy.

Databaseintermediate

Building Real-time Features with Supabase

Real-time features sell products, but they also break in spectacular ways if you do not respect the limits of the underlying broker. This playbook is how I add live subscriptions, presence, and optimistic updates to a React app using Supabase, without ending up with a UI that flickers on every reconnection. It covers schema design, RLS, presence, and the patterns that keep real-time work feeling instant rather than fragile.

AI Integrationintermediate

Building an AI Chatbot with Streaming

Most chatbot demos look great until a real user asks something unexpected, the network blips, or the bill arrives. This playbook is the production version: streaming responses, persistent conversations, sensible context windows, retries, rate limits, and the small UX details that make a chat interface feel native instead of bolted on. Everything here has been used in shipped products.

Filter by category

17 playbooks

Authenticationintermediate

Setting Up Authentication with Next.js

Authentication is the part of an app that has to be boring. This is the exact sequence I follow to bolt secure auth onto a Next.js project without inviting weird edge cases six months later. It covers provider choice, database design, session handling, route protection, and the small UI details that decide whether a login flow feels trustworthy or sketchy.

7 phases45 min5 outcomes

Next.jsNextAuth.jsPostgreSQLPrisma

Databaseintermediate

Building Real-time Features with Supabase

Real-time features sell products, but they also break in spectacular ways if you do not respect the limits of the underlying broker. This playbook is how I add live subscriptions, presence, and optimistic updates to a React app using Supabase, without ending up with a UI that flickers on every reconnection. It covers schema design, RLS, presence, and the patterns that keep real-time work feeling instant rather than fragile.

7 phases60 min5 outcomes

SupabaseReactTypeScriptPostgreSQL

AI Integrationintermediate

Building an AI Chatbot with Streaming

Most chatbot demos look great until a real user asks something unexpected, the network blips, or the bill arrives. This playbook is the production version: streaming responses, persistent conversations, sensible context windows, retries, rate limits, and the small UX details that make a chat interface feel native instead of bolted on. Everything here has been used in shipped products.

7 phases90 min5 outcomes

OpenAIVercel AI SDKNext.jsReact

DevOpsintermediate

CI/CD Pipeline with GitHub Actions

A CI pipeline is either a quiet asset or a noisy tax, and the difference is whether you took it seriously the first week or bolted it on after the team grew. This is the pipeline I set up on every new project: tests, lint, type-check, build, preview deploys, and production releases, all running in under five minutes and giving useful feedback when they fail.

7 phases45 min5 outcomes

GitHub ActionsDockerVercelNode.js

Performanceadvanced

Optimizing Performance with Edge Caching

Sub-100ms global response times are not magic, they are a stacked set of cache decisions made on purpose. This playbook is the layered caching strategy I use to keep dynamic apps feeling instant: static generation where it fits, edge functions where personalization is needed, on-demand revalidation, and the observability to know whether any of it is actually working.

7 phases60 min5 outcomes

VercelNext.jsRedisCDN

Securityadvanced

Securing Your API Endpoints

API security is not a sprinkle of middleware, it is a layered set of defenses where any one missing layer opens the door. This is my full checklist for hardening API endpoints: authentication, rate limiting, validation, CORS, audit logging, and the response headers that mitigate the long tail of browser-side attacks. Used on every production API I have shipped.

7 phases75 min5 outcomes

Next.jsJWTRedisZod

Databaseadvanced

Managing Database Migrations

Database migrations are the part of the system where a tiny mistake creates an outage that lasts hours. This is the playbook I follow when migrating a production schema: expand-then-contract, dual writes when needed, idempotent scripts, a real rollback plan, and verification that does not depend on the migration tool reporting success. Boring on purpose, because exciting migrations are the dangerous ones.

7 phases45 min5 outcomes

PostgreSQLPrismaDrizzleNode.js

AI Integrationadvanced

Building RAG Applications

Retrieval-augmented generation looks simple in a demo and stays simple until your knowledge base is bigger than a thousand documents, chunks overlap badly, or relevance scores stop making sense. This is my end-to-end RAG playbook: document processing, embedding pipelines, retrieval tuning, prompt design, and the evaluation harness that tells you whether changes are actually improving results.

7 phases120 min5 outcomes

OpenAIPineconeLangChainNext.js

Databaseadvanced

Multi-Tenant SaaS Architecture

Multi-tenancy is one of the highest-leverage architectural decisions in a SaaS, and almost impossible to fix later. This playbook is the model I use to design tenant isolation that scales from ten customers to ten thousand: shared schema with row-level isolation, tenant-scoped routing, configuration, billing, and an admin layer that lets you operate the platform without breaking customer trust.

7 phases90 min5 outcomes

PostgreSQLNext.jsPrismaVercel

DevOpsintermediate

Production Monitoring & Observability

Observability is not three pillars on a slide, it is the difference between knowing why your system is misbehaving and guessing. This playbook is the monitoring stack I deploy on every production system: error tracking, structured logging, performance metrics, distributed tracing, and the dashboards and alerts that turn raw data into actionable signal without paging everyone at 3 AM.

7 phases60 min5 outcomes

VercelSentryLogTailOpenTelemetry

AI Integrationintermediate

Shipping AI Features Without the Hype Tax

Most AI features ship as a demo that survives one round of investor questions and then quietly dies in production. This is the discipline that gets AI features past that wall: small scope, real evals, careful rollouts, and instrumentation that catches drift early. The same loop I run when I add AI capabilities to an existing product, on a real timeline with real users.

7 phases120 min5 outcomes

AnthropicOpenAIVercel AI SDKPostgreSQL+1

Architectureadvanced

Migrating a Monolith to Microservices

Most monolith-to-microservices stories end as cautionary tales because the team tried to design the future architecture instead of evolving toward it. This playbook is the staged migration I run: map the domain, find natural seams, extract behind a stable façade, adopt event-driven communication where it pays off, and decommission the old system gradually. Boring, slow, and the only version that consistently works.

8 phases180 min5 outcomes

Node.jsPostgreSQLKafkaKubernetes+1

Databaseintermediate

Choosing a Database in 2026

Database choice is one of the highest-cost, hardest-to-reverse technical decisions in a product. This playbook is the decision framework I walk teams through when they ask me to weigh in: define the workload first, pick a sensible default, evaluate hosted options on real criteria, plan for scale before you need it, prototype the hardest query, and document the choice so the next engineer does not have to relitigate it.

7 phases60 min5 outcomes

PostgreSQLMongoDBDynamoDBTurso+1

Hiringintermediate

Hiring Your First Engineer

Your first engineering hire shapes the next two years of the company more than almost any product decision. Most founders rush this and pay for it for a long time. This playbook is the hiring loop I recommend: scope the role honestly, source where engineers actually live, design a realistic interview, check references hard, and onboard with a real plan rather than a vague mandate.

7 phases90 min5 outcomes

ProcessInterviewingOnboarding

Architectureintermediate

Refactoring Without Freezing the Roadmap

Every codebase accumulates debt. The mistake is treating that as a binary choice between shipping features and paying it down. This playbook is how I keep both moving in parallel: map the pain honestly, avoid the rewrite trap, lock current behavior with tests, ship the refactor behind feature flags, keep PRs small, and measure outcomes so the team knows the work is paying off.

7 phases60 min5 outcomes

ProcessFeature FlagsTesting

Frontendbeginner

Picking a Frontend Framework in 2026

Frontend framework debates are the bikeshed of our industry, and they cost teams real time. This playbook is the decision framework I use to settle the question quickly: profile the workload, decide on rendering strategy, pick the default for your shape of app, evaluate the alternatives honestly, pick the styling and deployment story, and document the choice so the team can move on.

7 phases45 min5 outcomes

Next.jsRemixAstroSvelteKit

Architectureadvanced

Designing Event-Driven Systems

Event-driven architectures unlock real autonomy between services, and they expose a whole new category of bugs if you do not respect their constraints. This playbook is the design discipline I use: model events as facts, version schemas carefully, choose the right broker, build idempotent consumers, handle ordering and failure, and add the observability that makes async systems debuggable in production.

7 phases120 min5 outcomes

KafkaRedis StreamsEventBridgePostgreSQL

Working on something serious?

I can run any of these for you

The playbooks are public on purpose. If you want a partner who runs them end to end instead of handing you a checklist, that is what the studio is for.

Start a project Read the insights