Tech Stack for Indie Hackers: Keep It Simple and Iterate Fast
A no-nonsense guide to building, deploying, and scaling your solo project.
If you're a developer, there's a good chance you're thinking about launching a project of your own. But what’s the best tech stack? How do you deploy it? What should you focus on? In this article, I’ll give you some practical advice to help you get started quickly—and keep a clear path for scaling later.
Infrastructure and Deployment
Keep it really simple. Get a cheap Hetzner instance and install Coolify on it. Stick with a single-instance deployment. Provide a Dockerfile for your app—Coolify will build and deploy it for you. Once you’ve got your domain name, configure it in Coolify to get HTTPS with free SSL certificates.
For storage, just use Postgres and manage it with Coolify. It takes just a couple of clicks to get it running on the same Hetzner instance. One thing I’d still recommend: configure automatic database backups. Choose a frequency that works for you—it’s also handled by Coolify, and your snapshots will be stored in AWS S3 (or any compatible object storage).
Coolify also gives you built-in CI/CD. Push your code to a private GitHub repo, connect it with Coolify, and it will build and deploy from the main branch automatically.
Language Choice
This one’s easy: pick what you're most comfortable with. You can package almost anything into a Docker image and ship it.
Personally, I’d pick Clojure for the backend. A few reasons why:
Dynamic types – Controversial, but for a solo developer it’s a no-brainer. You’ll iterate much faster.
Hiccup – Hands-down the best way to work with HTML templates, in my opinion.
JVM performance – Don’t stress about it. It’s more than good enough, and if your project takes off, you can optimize later.
If I’m not planning rich frontend functionality, I stick with HTMX as long as possible. But if it starts leaning toward an SPA, I’d go with React + JavaScript to keep things straightforward.
Write High-Level Tests
I highly recommend spending time writing tests. Be pragmatic—don’t go too deep. Focus on core scenarios: happy paths, failures, edge cases.
For web apps, API-level testing usually hits the sweet spot. Set up test data, call your API, and validate both the response and the resulting DB state. You'll thank yourself later—especially when it’s time to refactor.
Monitoring and Observability
Coolify gives you basic log viewing, but it’s not enough. Set up host metrics alerts (CPU and memory usage). Also, add a simple health check that emails you if the app goes down. For exceptions, use something like Sentry to get visibility and alerts.
Use Managed Services for the Hard Stuff
Some problems are deceptively hard to solve well—authentication and payments are at the top of that list. Don’t build your own auth system unless you absolutely have to. Use a managed service like Clerk, Kinde, or Auth0. They handle password security, social logins, multi-factor auth, and session management—saving you a lot of time and potential vulnerabilities.
Same goes for payments: just use Stripe. It’s incredibly well-documented, widely supported, and gives you features like subscriptions, invoices, refunds, and webhook events out of the box. You’ll also learn a lot by integrating these services—it’s valuable experience, and it keeps your focus on building your product, not re-inventing the wheel.
Future Scaling Path
Don’t worry about scaling too early. You can always scale vertically by upgrading your instance. But if things go well and your traffic grows, you still have a clear path forward:
Move Postgres to a managed solution (AWS RDS, Aurora, Neon, etc.)
Use the same Dockerfile, but deploy it with a container orchestrator (AWS ECS Fargate, GCP, DigitalOcean, etc.)
Add a load balancer in front
That’s it. Keep it simple. Avoid premature optimizations. Happy coding!