Web Architecture

Next.js vs Remix in 2026: An Operator's Perspective

The framework debate is usually framed as a developer preference question. It's actually a systems question: which one is easier to reason about, maintain, and scale with a team that may not all be framework experts?

Postgres Row-Level Security: A Production Guide for Multi-Tenant SaaS

RLS is the correct way to enforce tenant isolation at the database layer. Here's how to implement it without destroying query performance — and the design decisions that matter.

tRPC vs REST vs GraphQL for B2B SaaS in 2026: An Operator's Decision Framework

The API layer choice is one of the longer-lived architectural decisions you'll make. Here's the framework that actually matches the tradeoffs at $1M–$20M ARR.

Type Safety at the Boundaries: How I Use TypeScript and Zod in Production

TypeScript gives you type safety at compile time. Zod gives you runtime validation. Together, they eliminate an entire category of production bugs. Here's the pattern I use across every project.

When to Rebuild vs. Refactor: A Decision Framework for SaaS Teams

A concrete decision framework for technical founders choosing between rebuild and refactor, with specific signals and measurable thresholds.

How to Audit Technical Debt in a SaaS Codebase

A practical audit framework for SaaS CTOs: what to measure, specific thresholds for each signal, and how to triage findings into actionable categories.

The Real Cost of Technical Debt at $5M–$20M ARR

Technical debt is often framed as an engineering problem. At $5M–$20M ARR, it's a revenue problem. Here's how to quantify it and when the rebuild math actually works.

Headless Commerce vs. Shopify Plus: When Headless Earns Its Complexity

Headless commerce adds $80k–$200k in build cost and ongoing engineering overhead. Here's the specific threshold framework for when that cost is justified.

The 5 Web Architecture Decisions That Will Cost You $100k If You Get Them Wrong

Most scaling pain isn't bad luck — it's the consequence of five specific architecture decisions made in year one. Here's what they are and how to make them correctly the first time.

Internal Tools vs. Off-the-Shelf Software: When Custom Builds Win

A specific decision framework for founders evaluating build vs. buy for internal tools, including the cost crossover point and a real case study from Pulse CRM.

Supabase at Scale: What Changes When You Hit 1M+ Events Per Day

Supabase is an excellent starting point. It's also a platform that can surprise you at scale if you haven't designed around its limits. Here's what changes at 1M+ events/day.

Multi-Tenant SaaS Architecture: The Supabase + RLS Approach and Its Limits

How to implement multi-tenant isolation using Supabase and Row-Level Security, why it works well below $5M ARR, and the specific signals that indicate you've outgrown it.

Five API Design Patterns I Use on Every Next.js Project

After years of building Next.js backends for production apps, I've settled on a handful of patterns that prevent the most common and expensive mistakes. These aren't opinions — they're the result of debugging production failures.

The Database Decisions That Will Define Your SaaS at Scale

Most early-stage SaaS teams make their database decisions based on what the first developer was comfortable with. By the time they hit 100k users, those decisions cost $200k to unwind. Here's how to make them correctly the first time.

Next.js App Router in Production: The Patterns That Actually Work

After shipping four production apps on Next.js App Router, I've learned what the documentation doesn't tell you. These are the patterns I reach for every time — and the ones I've stopped using.

Component Library Decisions: Build, Buy, or Borrow

The choice between a custom component library, a headless system, or a full-stack UI kit shapes everything downstream. Here's the framework.

Architecture for Speed: Building Sites That Feel Instant

Performance isn't a feature you add — it's a consequence of decisions you make at the architecture level. Here's how to get them right.