Steve Hanov runs six profitable SaaS businesses—websequencediagrams.com, zwibbler.com, rhymebrain.com, and three others—each generating $10K monthly recurring revenue. His total infrastructure cost: $20 per month. A single Linode VPS, Go backends, and SQLite databases replace the AWS labyrinths and Kubernetes sprawl that dominate tech discourse. His blog post hit Hacker News with 641 points on April 12, 2026, igniting fierce debate: Is infrastructure minimalism viable at scale, or is this reckless oversimplification?
The answer matters. Developers waste months building “scalable” infrastructure before validating product-market fit. Steve’s portfolio proves $10K MRR doesn’t require cloud vendor lock-in or microservices complexity. The real bottleneck isn’t infrastructure—it’s customer acquisition.
The Stack That Actually Works
Steve’s architecture is intentionally simple: single VPS ($5-10/month), Go compiled binaries, SQLite with Write-Ahead Logging, and Litestream for continuous S3 backups. No AWS. No Kubernetes. No microservices. Six products run on this foundation.
The cost breakdown: $5-10 for a VPS, $5 for GitHub Copilot, $5 miscellaneous. That’s $20/month supporting $60K monthly revenue. Infrastructure overhead: 0.03%. For context, a traditional AWS setup—EC2 instances, RDS databases, load balancers, CloudWatch monitoring—costs $200+ monthly for equivalent performance at this scale.
Performance claims hold up. Go handles 10,000s of requests per second on a single VPS. SQLite with WAL mode handles thousands of concurrent users on NVMe storage. The secret is WAL mode configuration—concurrent reads with a single writer, eliminating the database lock bottleneck that plagues default SQLite.
PRAGMA journal_mode=WAL; -- Enable Write-Ahead Logging
PRAGMA synchronous=NORMAL; -- Balance safety and speed
PRAGMA busy_timeout=5000; -- Handle lock contentionLitestream provides disaster recovery comparable to Postgres or MySQL, streaming incremental backups to S3 in the background. No complex replication infrastructure required.
Why Go Crushes Node.js and Python
Language choice directly impacts infrastructure costs. 2026 benchmarks show Go’s dramatic performance advantage: Fiber (Go framework) handles 214,000 JSON requests per second. FastAPI (Python’s fastest async framework) manages 24,800 requests per second—an 8.6x difference.
Real-world migrations validate the gains. Uber’s Python-to-Go migration cut p99 latency from 45ms to 4ms and reduced server costs 40%. Dropbox reported Go services handle 4x more requests per CPU core compared to Python services. The math is simple: Go’s performance means a $10/month VPS handles workloads requiring $50-100/month in Python or Node.js infrastructure.
Deployment simplicity matters too. Go compiles to a single statically-linked binary. No npm packages. No virtualenvs. No runtime dependencies. Deploy via `scp`, restart the service, and you’re live. Steve’s approach emphasizes this: “The goal is to serve requests, not to maintain infrastructure.”
The Hacker News Reality Check
The HN discussion (641 points, 200+ comments) reveals nuanced agreement and pushback. Critics noted real limitations: SQLite’s single-writer constraint chokes at hundreds of concurrent writes per second. Schema migrations on large SQLite tables are painful compared to Postgres tooling. Single-node architecture can’t serve global users efficiently without accepting high latency.
But the community consensus surprised skeptics. “SQLite with WAL is the biggest money saver,” one highly-upvoted comment noted. “You can go a long way, MRR-wise, with a simpler architecture.” The debate wasn’t minimalism versus scalability—it was premature optimization versus validated constraints.
Engineers pushed back on the $5/month VPS constraint. “Infrastructure costs represent 0.15% of $10K MRR revenue,” one comment argued. “Spending time on [1GB RAM] constraints outweighs minimal monthly savings.” The pragmatic take: $15/month for 4-8GB VPS is negligible at $10K MRR. Optimize for developer time, not server costs.
When Minimalism Breaks Down
SQLite’s single-writer limitation defines the first inflection point. Banking apps, real-time collaboration tools, and chat platforms need Postgres multi-writer concurrency. Write-heavy workloads hit this wall faster than expected—often at a few hundred writes per second, not thousands.
Geographic distribution creates the second constraint. A single VPS in US East causes 200ms+ latency for European and Asian users. Gaming, financial trading, and video streaming require multi-region infrastructure. Litestream provides disaster recovery, not high availability. Data loss is possible before replication completes—seconds to minutes of writes vanish if the server crashes.
But most developers hit these inflection points far later than anticipated. HN commenters suggested an incremental migration path: SQLite → Postgres on same VPS (Unix sockets) → Separate DB instance → Read replicas → Multi-region deployment. Add each layer when actual pain proves necessity, not when anticipated scale suggests it might be needed.
Infrastructure Complexity as Procrastination
“Cargo cult software engineering”—developers copy big tech architectures without their scale. One HN commenter captured it perfectly: “25 piece cloud deployments for little pie in the sky apps that will never see more than 200 users.” The result: wasted months on infrastructure before validating product.
Steve’s insight cuts through the noise: “Building took 6 weeks, getting customers took 6 months.” Infrastructure optimization is procrastination disguised as engineering. The real bottleneck for bootstrapped SaaS isn’t scalability—it’s distribution and customer acquisition.
The runway math validates this approach. Running lean at $20/month gives the same runway as raising $1M with massive burn rate. Low costs extend validation time indefinitely. 2026 data shows bootstrapped SaaS growing 44% year-over-year versus VC-backed companies at 42.8%. Lower burn rates enable profitable growth without external funding.
There’s a distinction between real constraints and artificial constraints. Optimizing for 1GB RAM when $15/month solves the problem is artificial. Avoiding Kubernetes until you have 10,000 users is smart constraint recognition. The challenge: knowing which is which.
Key Takeaways
- $10K MRR is achievable on $20/month infrastructure—Steve Hanov’s six-product portfolio proves minimal stacks work for profit-focused bootstrapped SaaS.
- Go outperforms Python 8.6x and Node.js 1.6x in production benchmarks, translating directly to lower infrastructure costs and faster response times.
- SQLite with WAL mode handles thousands of concurrent users, but single-writer limitation becomes a bottleneck for write-heavy applications at a few hundred writes per second.
- Start minimal and add complexity when actual pain—not anticipated scale—proves necessity. Migration path: SQLite → Postgres (same VPS) → separate instance → read replicas → multi-region.
- Infrastructure optimization before product validation is procrastination. The real bottleneck for early-stage SaaS: customer acquisition, not scalability.
For bootstrapped founders finding product-market fit, infrastructure minimalism isn’t reckless—it’s strategic. Cloud complexity can wait. Customers can’t.
