The 90/10 Rule: Stop Building What's Already Been Built

You had the idea. You opened your editor. Six weeks later, you're still setting up auth.

Sound familiar?

Here's the uncomfortable truth about building SaaS in 2026: 90% of every product you build is identical to what thousands of other developers built before you. The user table. The subscription logic. The email queue. The Stripe webhook handler that breaks every time Stripe releases a new API version.

None of that is your product. All of it eats your time.

The 10% that IS your product — the thing someone will actually pay money for — gets whatever hours are left over after you've debugged your third Supabase RLS policy of the week.

The fastest builders in 2026 have figured this out. They don't build the 90%. They skip it.

What's Actually in the 90%

If you've shipped more than one SaaS, you know this list by heart:

• Authentication — email/password, OAuth, magic links, session management, password reset
• Payments — Stripe checkout, subscription management, webhooks (the ones that eat three days minimum)
• Email — welcome sequence, password reset, invoice delivery, trial expiry warnings
• Database setup — user table, migrations, Row Level Security policies, indexes
• Multi-tenancy — if you're doing B2B, add another two weeks for org management and role-based access
• Background jobs — anything that can't happen in a request/response cycle
• Admin panel — user management, subscription oversight, support tooling
• Rate limiting, error monitoring, invoicing — none of which is optional in production

This is infrastructure. Absolutely necessary. Never differentiating.

Stripe's payment infrastructure took years and hundreds of engineers to build. You're not improving it. You're implementing it — again, from scratch, for the fifth time.

The dirty secret? Every Next.js SaaS you've ever seen shares about 90% of its code with every other Next.js SaaS. The code is different. The logic is identical.

What's Actually in the 10%

The 10% is what made you open a notes app at 2am. It's the specific insight that no existing tool captures correctly. The UX that makes users say "this finally makes sense."

• For a scheduling tool: the algorithm that understands how people actually think about calendar blocks
• For a code reviewer: the context it maintains about your team's specific patterns
• For an invoicing app: the workflow that handles edge cases your accountant described over lunch

Nobody else can build your 10%. You're the only one with that insight.

But everyone — including AI — can help you ship the 90%.

How the Fastest Builders Think About This in 2026

The vibe coding wave wasn't just hype about AI writing code faster. It was a mindset shift:

Old way: Plan → Architecture → Code → Debug → Review → Ship → Repeat
New way: Describe → Get a plan → Build → Ship → Iterate

Claude handles the how. You handle the what.

But here's what most vibe coding guides miss: the "what" is still genuinely hard. Which features to build first, how your database should be structured for scale, how to wire multi-tenancy into your auth flow — that's product management. AI coding tools are exceptional at syntax and implementation. They're not naturally equipped to handle strategy and prioritization.

This is where most "just vibe code it" projects get stuck. The code gets written. The architecture falls apart three weeks in.

The AI Product Manager

The most interesting shift happening in indie hacking right now isn't Claude's ability to write code. It's what happens when you give Claude the context to act as your PM.

Think about what a good product manager actually does:

1. Takes your vague idea and turns it into a concrete spec
2. Breaks that spec into ordered phases with clear dependencies
3. Keeps you from building the wrong thing first
4. Verifies that what was built matches what was planned

PropelKit has an AI PM built in — running on Claude — that does exactly this. You describe your product in plain English. The AI PM turns it into a phased plan: database schema first, then API routes, then UI components, then edge cases. Each phase is small enough to review in an hour, significant enough to ship something real.

/propelkit:new-project
> What are you building?

"A tool for freelancers to auto-generate invoices, 
track payment status, and send reminders automatically"

→ Phase 1: Invoice data model + Supabase migration
→ Phase 2: CRUD API routes + validation  
→ Phase 3: PDF generation + Resend email delivery
→ Phase 4: Payment status tracking dashboard
→ Phase 5: Automated reminder background jobs

You're not writing tickets. You're not maintaining a Notion doc. You're having a conversation with something that already knows your entire codebase and can execute.

The Actual Workflow

Here's what a day looks like when you've skipped the 90%:

Morning You describe a new feature: "I need users to be able to create subscription plans, invite teammates, and see usage per seat."

The AI PM breaks it into phases. Phase 1 is a database migration — two new tables, foreign keys, RLS policies. You run it. Done in 40 minutes.

Mid-morning Phase 2: API routes. Five endpoints. The AI PM writes them following your existing patterns, with your error handling, your auth middleware. You review the diff. Looks right. Ship it.

Afternoon Phase 3: The UI. The form, the invite flow, the usage table. You describe what it should look like. The AI PM generates components that match your existing design system — not generic shadcn defaults, but actually styled for your product.

End of day You've shipped a feature that would have taken two weeks from scratch. Not because the AI is magic, but because the infrastructure was already there.

Auth: done. Payments: done. Email: done. Background jobs: done.

The only thing you built today was your product.

The Numbers

Let's put actual time on this.

A standard SaaS MVP from scratch:

What you're building	Time from scratch
Authentication + social login	3–4 days
Stripe subscriptions + webhooks	4–5 days
Transactional email (welcome, reset, invoice)	2–3 days
Multi-tenancy + org management	5–7 days
Admin panel	2–3 days
Background jobs infrastructure	1–2 days
Your actual product feature	5–7 days
Total	22–31 days

With the 90% already handled:

What you're building	Time
Auth, payments, email, tenancy, admin, jobs	0 (done)
Your actual product feature	5–7 days
Total	5–7 days

That's a month saved before you write a single line of product code. And every new feature after that has the same multiplier.

What Claude Makes Possible Right Now

Claude's been getting serious attention lately — and the coding ability is just part of it. Claude Code (the CLI version) can hold your entire codebase in context, understand how your auth middleware connects to your API routes, and write new features that actually fit your existing architecture.

Not generic boilerplate dropped into your project. Code that follows your naming conventions, your error patterns, your TypeScript types.

When that works inside a framework that already handles the 90%, something shifts. You stop thinking in terms of "can I build this" and start thinking in terms of "should I build this." The infrastructure constraint disappears. The only bottleneck is product judgment.

This is what PropelKit was built for — Next.js 15, Supabase, Stripe, Razorpay, Resend, Inngest, all wired together, with an AI PM that knows the codebase and helps you build on top of it rather than fighting with it.

The people shipping the fastest in 2026 aren't necessarily the best engineers. They're the ones who stopped rebuilding auth.

Your 10% Is Waiting

The infrastructure problem isn't going away. Auth will always need to exist. Stripe will always have webhooks. Email will always need to be sent. The question isn't whether you build it — it's whether you build it yourself.

Every week you spend on the 90% is a week you didn't spend validating whether anyone wants your 10%.

Ship the thing that only you could build. The boring parts are taken care of.

Get PropelKit →