The $0 Bootstrap Stack: Building Enterprise Infrastructure for Free (With Upgrade Paths)

Yes, still June 1, 2025

After deciding to rebuild Piper Morgan from scratch, I faced a classic dilemma: How do you build enterprise-grade infrastructure when your budget is exactly zero dollars?

The answer turned out to be a 300-line bash script and some strategic thinking about the future.

The price of “enterprise”

Let me paint you a picture. A typical “enterprise” PM platform might run:

Auth0: $240/month
Datadog: $75/month after free tier
Pinecone: $70/month after free tier
Various other services: $200+/month

Total: $500–600/month before you’ve written a line of business logic.

For a side project? That’s a non-starter. But if working at startups taught me anything, it was that sometimes constraints force better decisions.

The philosophy

The key insight wasn’t to find free alternatives to enterprise tools. It was to find free tools that could become enterprise tools. Every component needed a clear upgrade path.

Here’s what that looked like:

Keycloak (free) → Auth0 ($240/month) when ready
ChromaDB (free) → Pinecone ($70/month) for scale
Prometheus/Grafana (free) → Datadog ($75/month) for convenience

The migration path was built in from day one. No vendor lock-in, just vendor… anticipation?

The bootstrap script

What emerged was a massive bash script that would set up everything:

#!/bin/bash
# bootstrap-stack.sh - Complete setup for $0 budget Piper Morgan infrastructure

echo "🚀 Setting up Piper Morgan Bootstrap Stack..."

This script created:

PostgreSQL for core data
Redis for caching and queues
Keycloak for authentication
ChromaDB for vector storage
Temporal for workflow orchestration
Prometheus/Grafana for monitoring
Traefik as API gateway

All running in Docker. All configured and ready. All free.

Hilarity ensues

Of course, nothing ever works on the first try. Remember those python environment issues from the last post? They had friends.

docker info
Cannot connect to the Docker daemon at 
unix:///Users/xian/.docker/run/docker.sock

Docker wasn’t running. Such a simple thing, but there I was, troubleshooting connection errors when the real problem was I forgot to start Docker Desktop. It’s always the simple things that get you.

Then came the environment variables. You know that feeling when you realize you’ve been debugging the wrong thing for an hour? That was me discovering my .env file wasn't being loaded because I was starting in the wrong directory.

What this stack actually does

Beyond saving $600/month, this bootstrap approach provided:

Complete isolation: Everything runs in containers
One-command setup: New developers can be up in minutes
Production parity: The same stack works locally and in production
Monitoring from day one: Not an afterthought

The monitoring deserves special mention. By starting with Prometheus and Grafana, I had visibility into everything from the beginning. When things broke (and oh, did they break), I could actually see why.

The hidden costs

“Free” doesn’t mean “cheap.” This approach cost:

2 weeks of setup time
Significant Docker expertise required
More operational complexity
No vendor support when things break

But here’s the thing: I was going to spend those 2 weeks debugging vendor integrations anyway. At least this way, I understood my entire stack.

“Build vs. buy” was one of the first business consulting cliché phrases I learned back at Groundswell when the millennium was young. To this day it’s a fraught choice. Do you buy and risk lock-in and escalating costs? Do you build (or fork) and end up with escalating maintenance costs, not to mention tons of time spent on things that are not in your core competence?

Since this is primarily a learning project for me, it was build all the way, baby!

The upgrade path magic

The real magic was in the upgrade paths. When you outgrow ChromaDB’s free tier, switching to Pinecone is a configuration change, not a code rewrite. When you need Auth0’s enterprise features, Keycloak has prepared you for OIDC patterns.

Every “free” choice was actually a “free to start” choice.

What I learned

Building on a budget forces architectural discipline. You can’t throw money at problems, so you have to actually solve them. You can’t rely on vendor magic, so you have to understand your stack.

The bootstrap script became a living document of the infrastructure. Every decision, every configuration, every gotcha — all captured in executable form.

Still setting up…

Well into what I thought would be a few hours of setup, I was still configuring Keycloak realms. My terminal history was a monument to trial and error:

docker-compose up -d
docker-compose down
docker-compose up -d --force-recreate
docker-compose down -v  # nuclear option

But each failure taught me something about the system I was building, even if it was only “that kind of failure seems to happen a lot — I should find out why!”

The payoff

Claude suggested I make this claim: “Six months later (spoiler alert), this infrastructure has scaled to handle real workloads without spending a dollar on infrastructure. The monitoring caught issues before users did. The auth system just worked. The vector database performed better than expected.”

This is, to put it charitably, a prediction, and to be honest not a really well grounded one, especially when it really gets going:

“Most importantly, when it came time to add that first paid service, the upgrade was seamless. The architecture was ready for it.”

The honest truth is the payoff so far is that I don’t have to have a budget besides my time and some LLM subscriptions right now to figure this thing out, and there’s a chance of scaling it someday without breaking the bank.

We’ll see. For now, I’ve got a manageable project. Sometimes the best investment is the time you spend not spending money.