# Best Indie Hacker Stack 2026: $5/mo, Zero Seats

> The full indie stack — VPS, Next.js, SQLite, Dodo, Telegram alerts, agent guardrails — for $5/mo flat. Every layer priced inside.

Source: https://boringpush.com/blog/boringpush-indie-hacker-stack

## The $400/month stack for a $0 MRR product

Count the subscriptions behind a typical indie launch: Vercel $20, Supabase $25, Clerk $25, Sentry $26, PostHog $0–49, Resend $20, CI minutes, uptime monitor, status page. Before one customer pays, the stack bills $150–400 monthly — a cash furnace that needs revenue to justify its own existence.

So founders optimize the wrong thing: cutting features to afford tooling, instead of cutting tooling to afford building. The stack becomes a second product requiring care, upgrades, and invoice reviews.

Best indie hacker stack thinking inverts it: flat hardware, owned data, $0 seats, boring tools — total fixed cost $5/month, so month one needs exactly one $199 sale to fund years.

## Subscription stack vs flat stack

| Layer | Subscription stack | Flat indie stack |
|---|---|---|
| Hosting | Vercel $20 + meters | $5 VPS, $0 meters |
| Database | Managed $15–50 | SQLite file, $0 |
| Auth | Per-seat $25+ | NextAuth self-host, $0 |
| Billing | Stripe % + tooling | Dodo lifetime, same % |
| Alerts | Sentry $26–49 | Telegram bot, $0 |
| Analytics | $0–49 metered | Self-hosted, $0 |
| CI/deploys | Minutes metered | git push, $0 |
| Monthly total | $150–400+ | $5 flat |

Three details make flat win structurally, not just cheaply:

1. **Seats tax the funnel.** Per-seat tools charge per free user — growth increases costs before revenue. Flat tools charge per box: ten users or ten thousand cost the same $5 until hardware limits (years away for most). Growth should dilute costs, not multiply them.
2. **Meters punish launches.** Viral months multiply every usage line simultaneously — success becomes an invoice review. Flat hardware absorbs spikes free (Cloudflare edge in front), so launches are pure upside. Metered stacks make founders fear the front page; flat stacks make them chase it.
3. **Owned data compounds.** SQLite rows, local logs, self-hosted analytics — everything queryable forever with SQL, portable with a file copy. Vendor dashboards rent your own behavior back to you with export limits. Data you hold is an asset; data you rent is a subscription.

The levelsio post proved the philosophy. This one prices the stack.

## Best indie hacker stack layer cake

Every layer below, priced and standard — the same repo this site runs on.

**Step 1 — Foundation: box, app, data for $5.**

On a small server such as a Hetzner CX22 or a DigitalOcean droplet, BoringPush gives you Ubuntu, Node, a process manager, SQLite in write-ahead mode, Cloudflare Tunnel and Tailscale, set up by one script. Choose SQLite as the database, then ship with `bp deploy`, with zero CI minutes.

Next.js serves pages and API from one process; SQLite answers from local disk with no network hop; the tunnel exposes zero ports; the mesh carries admin. No poolers, no connection strings, no regions to pick. Foundation total: a flat server bill, fixed and bored.

**Step 2 — Money and doors: billing plus auth for $0 extra.**

Billing is a lifetime deal ($199 once) through Dodo, behind the same interface as Stripe and LemonSqueezy. Auth is Google sign-in plus email magic links, with users in your own database. The paywall is one access switch downstream of both.

Lifetime pricing front-loads runway ($40k per 200 buyers, no churn clock); passwordless auth converts without per-seat bills; one access switch gates every surface from one place. Money in, doors guarded, receipts automatic — marginal monthly cost $0 on top of the box.

**Step 3 — Awareness and builders: alerts plus agents for $0.**

Alerts go to Telegram or Discord, with repeats held back for a minute. Agents build under a written rules file with a conventions map. Analytics and feedback boards live in your own database.

Outages reach your pocket before customers notice; agents build any feature inside schema-first fences; analytics and roadmaps live in your own database. Awareness without subscriptions, builders without salaries. The loop closes: alert, diagnose, fix, deploy — all from the phone, all flat.

That's the whole promise — the whole company for $5/month.

## Stack bills at three scales

| Scale | Subscription stack/mo | Flat stack/mo |
|---|---|---|
| 0 users (building) | $150–250 | $5 |
| 500 users ($2k MRR) | $250–400 | $5 |
| 5k users ($20k MRR) | $500–1,500+ | $5–20 (bigger box) |
| Viral spike month | +$500–1,800 spike | +$0 |
| Seats added | +$25–50 each | +$0 |

Admitting the tax: flat means you own the pager (updates, snapshots, disk watch — ~1 hour monthly) and forgo vendor dashboards' polish. Price the hour against the delta: at $300/mo saved it pays $300; at $1,500/mo saved it pays $1,500.

## FAQ

### Is best indie hacker stack 2026 really just cheap tools?

No — it's aligned tools: flat pricing (costs dilute with growth), owned data (portable, queryable), boring tech (debuggable at 2am), agent fences (builders without salaries). Cheap is the side effect; alignment is the strategy. A $5 stack that fights you costs more than a $400 stack that flows — this one flows because every layer was picked for solo operability first, price second.

### What breaks first when the stack scales?

Write contention (SQLite is a single writer, so switch the database setting), payout complexity (lifetime → add subscriptions), support volume (inbox → helpdesk). Each has a rehearsed graduation, none requires rewrites (parity, interfaces, thin routes). Scaling events are planned upgrades, not emergencies — the stack grows by flipping switches, not rebuilding foundations.

### How does this compare to the classic Vercel + Supabase stack?

Same developer experience, opposite economics: Vercel/Supabase optimizes for zero-ops polish at metered prices; this stack optimizes for flat costs with one owned hour monthly. DX gap: small (one push vs dashboard clicks). Bill gap: 30–300x at scale.

Polish gap: real (their dashboards shine). Choose by what constrains you — time (rent polish) or money (own the box). Most indies are money-constrained.

### Can a non-technical founder run this stack?

With an agent, yes: the guardrailed pipeline (schema → verbs → route → UI) lets AI do the typing while the founder decides product. The phone loop covers operations (alerts, approvals, rollbacks).

Pure-no-code founders still start visual (Divjoy for landing), then graduate here when auth/money/data arrive. Technical bar: read logs, approve diffs — agent does the rest.

### What about team collaboration — seats, roles, review queues?

Deliberately absent at this scale: the stack assumes one founder plus agents (the highest-leverage team of 2026). Past ~3 humans, add roles table plus review habits (the bridge-quarter post details it) — days of work on thin routes, not a migration. Buy org charts the quarter the org forms; until then every seat-shaped dollar is optional burn.

### Why $199 once instead of free or subscription?

Free means unsupported (or ad-supported attention games); subscriptions fund services this kit doesn't run (no hosted anything). $199 once prices the decisions (conventions, parity, guards, playbooks) plus lifetime updates — the artifact, not a relationship. Lifetime aligns incentives: we win when you ship, not when you linger. If you can think it, BoringPush can make it — the repo is the proof.

## Keep reading

- [Ship From Phone Like levelsio: $5 Box Empire](/blog/levelsio-ship-from-phone-style) — the philosophy behind the $5 number
- [Deploy Next.js on Hetzner $5 by Dinner Tonight](/blog/deploy-nextjs-hetzner-vps) — the foundation afternoon, step by step
- [We Left Vercel at $1,800/mo for a $5 VPS](/blog/vercel-1800-month-to-5-vps) — the receipt that justifies the switch