The Stack Behind Everything I Build: Next.js, Supabase, and Why Boring Tech Wins

One Stack to Rule Them All

I run multiple SaaS products, a marketing agency, a publisher network, and a property business. Every single one of them that touches code runs on the same stack:

• Next.js 15 with the App Router
• Supabase for the database and auth
• Vercel for hosting and deployment
• TypeScript in strict mode, everywhere
• n8n for backend automation
• Resend for transactional email

That's the list. It hasn't changed much in the last two years, and that's entirely the point.

Why "Boring" Tech Wins

Every few months there's a new framework, a new database, a new deployment platform that's supposedly going to change everything. I've stopped paying attention.

Boring tech wins because:

• It's battle-tested. The edge cases have been found and fixed by thousands of developers before me.
• The documentation is mature. When I hit a problem at midnight, the answer exists.
• The ecosystem is deep. Libraries, plugins, integrations — they all exist and they all work.
• Hiring and collaboration are easier. Everyone knows React. Everyone can read TypeScript.

I'm not building technology for the sake of it. I'm building products that need to make money and serve customers. The stack is a means to an end, and the best means is the one that gets out of my way.

The Power of Shared Infrastructure

Here's where the real leverage kicks in. Because every venture runs on the same stack, I get compounding benefits:

Shared code patterns. I've built a library of components, hooks, and utilities that work across every project. A data table component I built for Bytable works identically in LUFU CRM. Auth flows, API patterns, form handling — write once, use everywhere.

Shared database knowledge. Every project uses Supabase, which means every project uses Postgres. My Row Level Security patterns, my migration workflows, my backup strategies — they're all transferable. When I solve a performance issue on one project, that knowledge applies to all of them.

Shared deployment pipeline. Every project deploys to Vercel the same way. Push to main, preview deploys on PRs, environment variables managed consistently. I don't think about deployment. It just works.

Shared mental model. This is the underrated one. When I context-switch from Stoneforms to LittleSpoon, I'm not switching languages, frameworks, or paradigms. The file structure is familiar. The patterns are the same. I can be productive within seconds, not hours.

TypeScript Strict Mode: Non-Negotiable

Every project runs TypeScript in strict mode. No exceptions, no any types sneaking in.

This isn't perfectionism. It's pragmatism. When you're moving fast across multiple codebases, the compiler is your safety net. It catches the mistakes that would otherwise become production bugs at 2am.

Strict mode also makes Claude's code assistance dramatically better. When the types are precise, the AI understands the codebase properly and generates code that actually fits.

n8n: The Backend Glue

I don't build traditional backend services for most things. Instead, n8n handles the orchestration:

• Webhook endpoints that receive data from external services
• Scheduled jobs that run data pipelines, generate reports, and sync systems
• Event-driven workflows that react to database changes, form submissions, and API calls

n8n is self-hosted, which means I control the infrastructure and there are no per-execution costs. For the volume of automations I run across all ventures, this saves a significant amount compared to cloud-based alternatives.

The workflows connect to Supabase, Claude API, HubSpot, Stripe, Google APIs, and dozens of other services. It's the nervous system that connects all the ventures.

Resend for Email

Email sounds simple until you need reliable deliverability, proper DKIM/SPF setup, and clean APIs. Resend handles all of that. Every venture that sends email — client reports at Byter, onboarding sequences for SaaS products, transactional notifications — goes through Resend.

One provider, one dashboard, consistent deliverability monitoring.

Real Example: Spinning Up a New Project

When I started building Stoneforms, here's what the first day looked like:

1. npx create-next-app with my standard config
2. Connect to a new Supabase project (took 3 minutes)
3. Copy over my auth setup, layout components, and utility functions
4. Deploy to Vercel (automatic via Git push)
5. Set up n8n workflows for form processing and notifications

By the end of day one, I had a working application with auth, a database, email, and automation. Not a prototype — a working app that could accept real users.

That speed is only possible because the stack is the same every time.

The Takeaway

You don't need the latest framework. You need a stack you know deeply, that you can move fast with, and that scales with your ambition.

Pick your tools. Learn them properly. Use them everywhere. The compound returns on consistency will outperform any shiny new technology.