You Don’t Need a $100 Cloud Bill to Build a Real SaaS

We’ve quietly accepted something strange in modern web development:

Spending $100/month on infrastructure before you have a single customer is considered normal.

It shouldn’t be.

If you follow the average “build a SaaS” tutorial today, this is what happens on Day 1:

• Frontend hosting (Vercel / Netlify): $20/month
• Database (Neon / Supabase): Free → $25/month
• Auth (Clerk / Auth0): Free tier → per-user pricing
• Redis / cron / queues: Usage-based

Before validation.
Before revenue.
Before your first Stripe payment.

You’re already burning $50–$100/month.

For funded startups, this is noise.
For solo developers and indie builders, it’s pressure—and pressure kills good ideas early.

So I asked a boring but important question:

What does a real, production-ready SaaS actually need?

The answer is uncomfortable:

Far less than we’ve been told.

The Constraint That Changes Everything

Instead of optimizing for infinite scale, I optimized for:

• One server
• Predictable costs
• No per-user fees
• No vendor lock-in
• Easy debugging at 2 a.m.

That single constraint changes every architectural decision.

The result is a fully functional, production-ready SaaS running comfortably on a single $5 VPS.

And in many cases—it’s faster than the cloud.

High-Level Architecture

No magic platforms.
No proprietary services.
Everything replaceable.

SQLite, On Purpose

We’ve been trained to believe that “production” means a managed Postgres cluster.

Most SaaS apps don’t need one.

SQLite in WAL (Write-Ahead Logging) mode provides:

• Zero network latency
• No connection limits
• Extremely fast reads
• Reliable writes for most SaaS workloads

When your application and database live on the same NVMe disk, query latency drops from 40–60ms (cloud database) to sub-millisecond.

What About Data Loss?

That’s the real concern—and it’s valid.

The fix is straightforward:

• Continuous replication to object storage
• Point-in-time restores
• Fast recovery on a new VPS

Your server is disposable.
Your data is not.

Authentication Without the Tax

Most applications need:

• Secure sessions
• OAuth (Google, GitHub, etc.)
• Password resets

Not an identity SaaS.

Good, production-grade options include:

• Better Auth
• Auth.js
• Authentik
• Keycloak (if you need enterprise IAM)

The key principle is simple:

Authentication data lives in your database, not a third-party tenant.

No per-user pricing.
No lock-in.
No surprise invoices when you grow.

Deployment: Containers Over Platforms

Everything runs in Docker:

• The application
• Background workers
• Monitoring tools

Once the system is defined in a docker-compose.yml, deployment becomes boring:

1. Push code
2. Build image
3. Pull on server
4. Restart container

Boring is good.
Boring is reliable.

Optional Convenience: Self-Hosted PaaS

If you want a smoother developer experience without giving up control:

• Coolify
• Dokploy

They provide:

• Git-based deployments
• Environment variables
• Rollbacks
• SSL automation

All running on infrastructure you own.

Observability Without Enterprise Bills

With Prometheus and Grafana, you can monitor:

• CPU and memory usage
• Request latency
• Error rates
• Database performance

You don’t need Datadog to know when your app is unhealthy.

Why This Matters

This isn’t just about saving money.

It’s about runway.

When your SaaS costs $5/month:

• You can wait for product–market fit
• You can experiment freely
• You can run multiple projects on one server
• You’re not forced to monetize prematurely

When it costs $100/month:

• Every quiet month feels like failure
• Decisions become rushed
• Good ideas get killed too early

High infrastructure costs don’t just burn cash—they distort judgment.

Final Thought

You don’t need:

• A hyperscaler
• A dozen managed services
• A massive cloud budget

You need:

• One Linux server
• A boring, well-understood stack
• And the courage to own your infrastructure

Scale when it’s real.
Optimize when it hurts.

Until then—

stop renting complexity.