The Generic Stack: Redefining Rapid Application Development

The False Choice That's Killing Startups

Every startup founder faces the same brutal choice: move fast with prototypes that break in production, or spend months building "enterprise-grade" infrastructure before shipping anything. It's a false choice that has derailed countless promising companies—but it doesn't have to be this way.

The Generic Stack isn't just another development template—it's my solution to a problem that was driving me crazy. After setting up the same infrastructure patterns over and over for client projects with LibertAI, SatGo, and others, I finally got fed up with the repetition. Built on the principle that "shipping quickly shouldn't mean sacrificing control," it systematically eliminates the infrastructure busywork I was tired of recreating.

The Same Setup, Over and Over

Here's the thing that was driving me nuts: every new client project started the same way. Whether I was helping with decentralized AI infrastructure, Bitcoin payment systems, or mobile applications, I'd spend the first week setting up the exact same foundational pieces:

• Configuring Docker containers for development and production parity

• Setting up Terraform for infrastructure as code

• Wiring up deployment pipelines with proper secrets management

• Creating development environments that actually work on everyone's machine

• Configuring SSL certificates, DNS, and all the deployment ceremony

I'd end up with the same messy process every time: spin up a Hetzner box, configure SSH keys, write yet another set of Ansible playbooks for container deployment and Docker compositions. I even have a whole repo of these playbooks I stitched together over the years. It worked, but it was tedious and error-prone. Every new project meant rebuilding the same infrastructure patterns from scratch.

The "Screw It, I'm Making a Template" Moment

After the fourth or fifth project where I found myself copying and pasting the same Dockerfile configurations and Ansible playbooks, I hit my limit. This wasn't rocket science—it was just systematic infrastructure work that I'd figured out through trial and error. Why was I recreating it every time?

Then I discovered Kamal. Suddenly, all those Ansible playbooks I'd been writing and rewriting could be replaced with a single, declarative deployment configuration. Zero-downtime deployments, automatic SSL, proper secret management—everything I'd been cobbling together manually was just... handled.

That was the moment I realized I could systematize this entire process. Not just the deployment part, but the whole development-to-production pipeline. If I could combine the best tools I'd learned to use (Docker, Terraform, 1Password, Kamal) into a repeatable pattern, I'd never have to manually set up infrastructure again.

So I did what any lazy (efficient?) engineer would do: I turned my pain into a reusable solution. The Generic Stack isn't trying to solve every infrastructure problem in the world. It's just the systematic approach I wish I'd had when I started consulting—a way to get from zero to production-ready infrastructure without the repetitive setup work.

What Actually Makes It Different

The Generic Stack operates on one simple principle: shipping quickly shouldn't mean sacrificing control. Here's what that looks like in practice:

Container-First, Not Container-Later

Every component is containerized from day one. No more "let's Dockerize it later" promises that never happen. Your development environment is your production environment, just with different data.

One Command to Rule Them All

I was tired of juggling multiple terminal windows and hunting for the right ports every time I started working on a project. So I built a unified development experience:make dev — That's it.

This launches a perfectly orchestrated tmux session with Python FastAPI (port 8000), TypeScript web app (port 5173), Express API (port 3001), and a containerized PostgreSQL database. Everything hot-reloads, everything just works, and I never have to remember port numbers again.

Deployment That Actually Works

The deployment infrastructure uses the tools I've learned work best together after years of trial and error:

• Terraform + Kamal: Infrastructure as Code with zero-downtime deployments and automatic SSL

• 1Password integration: No more plaintext secrets or .env files in repositories

• Digital Ocean + Cloudflare: Reliable hosting for $6-15/month total—no enterprise complexity

How It Actually Works in Practice

I've got three live examples running right now that show different use cases:

• generic.krondor.org: The documentation and roadmap site

• ts.generic.krondor.org: TypeScript stack with Vite + React and Express API

• py.generic.krondor.org: Python stack with FastAPI, PostgreSQL, and Google OAuth

All three run on the same infrastructure for about $6-15/month total. No AWS bills that surprise you, no vendor lock-in, no "oops we need Kubernetes now" moments.

The Real Impact: Time I Don't Have to Waste Anymore

Here's what changed for my project work: instead of spending the first week of every project doing the same infrastructure setup, I can now focus on the stuff that actually matters—the business logic, the user experience, the problems that are unique to each client.

My clients and I get production-ready infrastructure on day one, not week three. They can iterate rapidly without worrying about whether their prototype will survive real users. And when they need to scale, the infrastructure is already designed to handle it.

Beyond Just Another Template

What started as pure laziness (efficiency?) turned into something more valuable: a systematic approach to the infrastructure patterns that actually matter. Instead of reinventing the wheel every time, I now have a foundation that handles the boring stuff so I can focus on the interesting problems.

I'm already working on extensions—a Rust stack, LLM integration patterns, enhanced observability. The beauty of systematizing this work is that improvements benefit every project going forward instead of just the current one.

The End of Repetitive Infrastructure Work

The Generic Stack isn't revolutionary technology—it's just the result of getting tired of doing the same work over and over. Sometimes the best innovations come from solving your own annoying problems.

If you're spending your first week on every project setting up the same Docker containers, Terraform configurations, and deployment pipelines, you're probably feeling the same frustration I was. The false choice between speed and stability doesn't have to exist when you have systematic solutions to systematic problems.

Now I can spend my time on the stuff that actually matters: building features, solving business problems, and helping startups grow. That's what I'd rather be billing for anyway.