Indie Hacker From 0 to Hero

7/28/2025

In April 2024, I wrote an article about Indie Hacker Tech Stack 2024, which detailed the recommended technology stacks and platforms for indie development. Over time, many of the recommended tech stacks have become the most popular choices and work best with AI coding tools.

Since then, I've been getting questions from fellow developers about which tech stacks and platforms to recommend. Many beginners in indie development are cost-conscious, especially since most platforms require credit cards and monthly bills can sometimes spiral out of control. This has kept many people on the sidelines.

Since that previous blog post is getting outdated and some recommended tech stacks and platforms have changed, I decided to write this comprehensive guide on how to start your indie development journey on a budget. This article is aimed at cost-conscious developers - experienced indie hackers can skip to the end.

Latest Tech Stack Choices

First, I need to clarify that this article focuses on full-stack web development tech stacks and platform choices. For mobile development, backend-only, and browser extension development, please give this post a like and follow - I might cover those topics in future posts.

Let me start by sharing my latest full-stack web development tech stack choices for indie projects.

First, let's talk about ecosystem choices. There are many full-stack development options like Next.js, Nuxt, Laravel, Django, .NET Core, Ruby on Rails, and more.

While I'm not entirely satisfied with many features and patterns in Next.js 14 and 15, it's still the only full-stack framework I personally recommend right now.

The reason is that Next.js benefits from the React ecosystem, which has the most active community. A huge number of open-source libraries and platforms prioritize Next.js support, which gives you two major advantages.

First, no matter what platform you choose or what requirements you have, finding relevant open-source libraries and platform documentation is most convenient. Second, for AI and AI IDEs, a rich ecosystem with comprehensive documentation means AI-generated code is more accurate and has fewer bugs.

The ecosystem monopoly effect seems even stronger in the AI era, making it harder for new frameworks to break through.

Next.js is also very flexible for different needs, supporting SSR, SSG, ISR, and other rendering modes that can satisfy most business requirements.

So let me share my specific Next.js tech choices. While most tech decisions don't directly affect costs, some technology choices do limit your deployment platform options.

For example, if you want to add email functionality to your project and choose the nodemailer library, this library won't work on many Edge platforms like Cloudflare Workers.

After running into many issues, I want to share a universal Next.js tech stack that's been tested and can deploy to virtually any platform. It covers most SaaS needs:

Let me briefly explain some tech choices that aren't directly related to costs:

  • Database: Drizzle ORM is a very lightweight ORM library that's type-safe and supports multiple databases like PostgreSQL, MySQL, and SQLite. Most importantly, it performs better than Prisma and has better Edge platform compatibility.
  • Authentication: Better Auth is a very comprehensive auth library that supports multiple authentication methods like Email/Password and Social Login, plus various plugins like Admin plugins. It also has better documentation than Auth.js.
  • Blog and Docs: I chose Fumadocs. Those familiar with my open-source blog project know I usually use content-collections for MDX management and rendering. But Fumadocs supports both documentation features (like search, theming, rendering) and MDX management, so I'm gradually migrating to it to reduce dependencies and unify the tech stack.
  • Lint and Formatter: I chose Biome instead of the default ESLint + Prettier combo because it's built with Rust for better performance, and being an all-in-one solution makes configuration much simpler.

Define Your Needs and Costs

First, I want to clarify that this budget-friendly indie development approach is aimed at profitable or soon-to-be profitable products, not personal projects or hobby projects.

If it's a personal project for you and your friends, then costs don't really matter - choose whatever tech stack and platforms you prefer. Most platforms have generous free tiers anyway. For example, with Vercel + Neon, if you're building something like a personal Chatbot, it's actually quite hard to hit Vercel's free tier limits.

If you're planning to develop a profitable project, or use a free product to build your reputation and convert some users to paid products, then you need to carefully consider your costs.

Before diving into specific costs, let's first discuss the three main approaches for budget-friendly web development:

1. Using Cloud Platform Free Tiers Examples: Supabase (Backend-as-a-Service), Neon (Serverless PostgreSQL), Railway (PaaS deployment), Fly.io (app deployment), Zeabur (PaaS deployment)

Pros:

  • Completely free to start
  • No server maintenance or backups required
  • Can handle future growth and traffic spikes

Cons:

  • Limited free quotas, paid plans kick in after limits
  • Some platforms require credit card verification
  • Once you exceed free tiers, most platforms become quite expensive
  • Some platforms don't allow commercial use on free plans (like Vercel free tier)

2. Going All-in with Cloudflare

Pros:

  • Cloudflare is known as the "Cyber Buddha" among developers
  • Free CDN, cheap compute, storage, logging services
  • For ~$5/month, you barely need to worry about traffic and costs

Cons:

  • Minimum ~$5/month investment required
  • Free tier services aren't robust enough with many limitations
  • Limited community support, many gotchas, requires figuring things out yourself

3. Self-Hosted Deployment Get a cheap VPS or VM and deploy everything yourself, using excellent open-source projects like Dokploy (self-hosted PaaS) or Coolify (open-source deployment platform).

Pros:

  • Complete customization and freedom
  • Low costs
  • Can deploy everything: your app, PostgreSQL database, Umami analytics, Unsend email service, etc. - one-stop solution for all costs

Cons:

  • Need to maintain servers yourself (high time cost)
  • Must consider service stability and security
  • Need to handle backups, monitoring, logging
  • Must plan your own scaling solutions for growth and traffic

Cloud Platform Approach

If you want to start with truly zero upfront costs, your only option is to use various cloud platforms' free tiers, or join startup programs from AWS, Azure, or Google Cloud (which give you significant cloud resource credits, but I won't cover those here).

Here are some platform combination suggestions you can reference:

Platform Combination Recommendations

Beginner Combo (Completely Free):

  • Deployment: Vercel (non-commercial projects)
  • Database: Supabase or Neon
  • Authentication: Clerk or self-implemented Better-Auth
  • Storage: Cloudflare R2
  • Email: Resend
  • Monthly cost: $0 (within free quotas)

Stable Production Combo (Small Commercial Projects):

  • Deployment: Vercel Pro
  • Database: Neon
  • Authentication: Clerk Pro
  • Storage: Cloudflare R2
  • Email: Resend Pro
  • Payments: Stripe or Creem
  • Estimated monthly cost: $25-100

Below are the free tier quotas for various cloud platforms:

Deployment Platforms

Vercel

  • Free tier:
    • 100GB bandwidth/month
    • 4 CPU-hours/month
    • 1M edge network requests/month
    • Custom domain support
  • Paid plan: Pro $20/month
  • Pros: Official Next.js support, fast deployment, global CDN, great developer experience, the gold standard for Next.js deployment.
  • Cons: Free tier doesn't support commercial projects, complex pricing structure, easy to get "surprise bills" without careful optimization.

Railway

  • Free tier: $5 credit/month (trial period), legacy users get $5/month free, then pay-as-you-use
  • Pricing: Pay by resource usage, approximately $0.000463/GB-hour (memory), $0.000231/vCPU-hour, $0.000000047683716/KB bandwidth
  • Pros: Flexible PaaS platform, supports multiple languages and frameworks, can deploy PostgreSQL databases and Docker containers, easy to use.
  • Cons: Pricing may be high for small projects, costs scale up quickly with traffic.

Fly.io

  • Free policy: Monthly bills under $5 are waived (unofficial commitment)
  • Pricing: shared-1x 256MB ~$1.94/month, performance CPU costs more
  • Billing items: Compute time, memory, storage, bandwidth
  • Pros: Global app deployment PaaS platform, supports multiple languages and Docker containers.
  • Cons: Small free policy could be cancelled at any time

Database Platforms

Supabase

  • Database free tier:
    • 500MB database storage
    • Maximum 2 projects
    • 5GB bandwidth
  • Paid plan: Pro $25/month (includes 8GB database, 100GB bandwidth)
  • Pros: Open-source Backend-as-a-Service (BaaS) platform providing PostgreSQL database, real-time features, built-in authentication, and file storage.
  • Cons: Free tier has small storage limits, complex queries may impact performance

Neon

  • Database free tier:
    • 0.5 GiB storage
    • 10 projects
    • 10 branches
    • 190 hours compute time/month
  • Paid plans: Launch $19/month, Scale $69/month
  • Pros: Serverless PostgreSQL, branching features, fast scaling
  • Cons: Free tier has small storage limits and compute time restrictions

Upstash (Serverless Redis/Kafka Service)

  • Cache free tier:
    • 10,000 requests/day
    • 256MB memory
  • Paid plans: Pay-as-you-go $0.2/100k requests, fixed plans $10-280/month
  • Pros: Serverless Redis/Kafka service, global edge deployment, pay-per-use
  • Cons: Free tier request limits, fixed plans expensive for small projects

Authentication Platforms

Clerk

  • Free tier:
    • 10,000 monthly active users
    • All authentication methods (email, social login, etc.)
    • Basic user management features
  • Paid plans: Pro $25/month (50,000 MAU), Enterprise custom
  • Pros: Great developer experience, rich UI components, multiple authentication methods
  • Cons: Relatively expensive, dependent on third-party service

Object Storage Platforms

Cloudflare R2

  • Free tier:
    • 10GB storage/month
    • 1,000,000 Class A operations (writes)/month
    • 10,000,000 Class B operations (reads)/month
    • No bandwidth charges
  • Paid pricing: $4.50/million Class A requests, $0.015/GB storage
  • Pros: No bandwidth fees, S3-compatible API, cheap pricing, global CDN support
  • Cons: Slower access from China, otherwise no major cons

Email Service Platforms

Resend

  • Free tier:
    • 3,000 emails/month
    • 100 emails/day
    • API and SDK support
  • Paid plans: Pro $20/month (50,000 emails), Scale $85/month (100,000 emails)
  • Pros: Developer-friendly, modern API, template system, high delivery rates
  • Cons: Relatively small free quota, stability of newer platform still being proven

Summary

The pros and cons of using cloud platforms' free tiers to start your indie development project are clear. You don't need to figure out and spend time implementing various features like newsletter functionality, email sending, login/registration, etc. You also don't need to maintain servers - just choose existing stable services and focus on your product itself.

The downside is that once traffic increases and you exceed free quotas, costs can scale up rapidly. Stories of getting hundreds or thousands of dollars in Vercel bills are common complaints on Reddit.

If you choose this approach, you must have a clear understanding of traffic and cost calculations from the beginning, with well-planned business models and profit plans. Otherwise, an indie project where costs exceed revenue will be hard to sustain.

However, I personally think there's no need to worry too much about traffic and cost scaling issues, because the reality is that most indie development projects don't have users or traffic for a long initial period.

As long as people pay for your product, you limit free user features, and you optimize Next.js well (like using more Edge Functions and less Image Optimization), building a project where revenue exceeds costs using the cloud platform approach is quite feasible.

I personally still recommend this approach: focus on product features, spend more time on marketing and promotion, and less time and energy on third-party services and technology. This aligns better with indie development philosophy.

Going All-in with Cloudflare

The second approach is to fully utilize the Cloudflare platform. This model is suitable for three situations:

  1. Developers with technical foundation who are willing to spend some time tinkering and learning.

  2. High-traffic, no-revenue projects that want to build reputation through free projects and tools to attract and convert customers.

  3. Developers who don't want to worry about traffic and cost scaling, looking for the most cost-effective platform.

I think all three scenarios are well-suited for going all-in with Cloudflare. While Cloudflare's free tier isn't stable enough for commercial projects (especially the Workers CPU time limits), their $5/month plan includes many services like Workers + KV + D1 + R2 + more. For a SaaS or content site, this is quite comprehensive.

Below are some Cloudflare platform services and features you can reference:

Workers Computing Platform

Cloudflare Workers

  • Free tier:
    • 100,000 requests per day
    • 10ms CPU time
  • $5 plan includes:
    • 10 million requests per month, +$0.30 per additional million
    • 30 million CPU ms per month, +$0.02 per additional million CPU ms
  • Pros: No bandwidth or traffic fees, no scaling concerns, cheap
  • Cons: CPU time limitations, non-standard Node.js environment, some scenarios require careful technical implementation

D1 Database

Cloudflare D1

  • Free tier:
    • 5GB storage/month
    • Read operations: 5 million/day
    • Write operations: 100,000/day
  • $5 plan includes:
    • Read operations: First 25 billion/month included + $0.001/million rows
    • Write operations: First 50 million/month included + $1.00/million rows
  • Pros: Cheap, no bandwidth or traffic fees, fast, supports various ORM frameworks
  • Cons: D1 is built on SQLite, so for high-traffic write-heavy scenarios, PostgreSQL databases are still more suitable

KV Storage Platform

Cloudflare KV

  • Free tier:
    • Read operations: 100,000/day
    • Write operations: 1,000/day
    • 1 GB storage
  • $5 plan includes:
    • Read operations: 10 million/month, + $0.50/million
    • Write operations: 1 million/month, + $5.00/million
    • 1 GB, + $0.50/GB-month
  • Pros: Cheap, no bandwidth or traffic fees, fast
  • Cons: KV storage is suitable for small projects, not ideal for large projects

Object Storage Platform

Cloudflare R2

  • Free tier:
    • 10GB storage/month
    • 1,000,000 Class A operations (writes)/month
    • 10,000,000 Class B operations (reads)/month
    • No bandwidth charges
  • Paid pricing: $4.50/million Class A requests, $0.015/GB storage
  • Pros: No bandwidth fees, S3-compatible API, cheap pricing, global CDN support
  • Cons: Slower access from China, otherwise no major drawbacks

Summary

The all-in Cloudflare approach is also the solution I currently choose for many projects. My several projects deployed on Cloudflare combined get hundreds of thousands of visits per month - like the blog you're currently reading and the NextDevKit project. I still haven't exceeded Cloudflare's $5/month plan.

Thanks to the OpenNext Cloudflare project, building a full-stack Next.js project on Cloudflare has become very simple, with seamless integration of various Cloudflare services like D1, KV, R2, and others mentioned above.

Moreover, Cloudflare's CDN is one of the few global free CDN services. While access speeds from China aren't great, for high-traffic projects targeting overseas markets, combined with proper caching strategies, it's an excellent choice.

Self-Hosted Deployment

The third approach is to purchase a VPS or VM and self-host all your services. The pros and cons of the self-hosted deployment model are quite clear.

Pros: Complete customization and freedom, full control over your services and data. A single VM can host your project, database, email service, logging service, data analytics service, etc. One-stop solution for all costs without relying on third-party services or worrying about price increases and third-party limitations.

Cons: Need to maintain servers yourself (high time cost), must consider service stability and security, and handle backups, monitoring, logging, etc. Unlike the previous two approaches, once traffic increases, you need to plan scaling solutions yourself, like buying more capacity or migrating services. You also need to consider server stability issues like DDoS attacks and traffic attacks.

Of course, you can choose some open-source self-hosted PaaS platforms to simplify your work, like Dokploy and Coolify. These projects provide many out-of-the-box features.

For example, the Dokploy project, once deployed on a VM, provides many out-of-the-box features like one-click deployment of open-source templates, CI/CD container auto-deployment, SSL certificate creation, automatic backups, scaling, and more.

Here are some container services I commonly use from Dokploy templates:

  • Data analytics services: Plausible (privacy-friendly web analytics) + Umami (open-source, privacy-friendly web analytics tool)
  • Email service: Unsend (open-source alternative to Resend for self-hosted email sending)
  • Databases: PostgreSQL + Redis
  • Monitoring service: Uptime Kuma (open-source service monitoring tool)
  • Backup service: Cloudflare R2
  • Automation service: n8n (open-source workflow automation tool, like Zapier)

The cost of this approach depends on your server expenses. You can choose stable virtual machines from major providers, or find cheaper VM service providers.

Other Costs

Besides deployment costs, there are some other expenses to consider. Here are some suggestions you can reference:

Domain Names

For an indie development project, a custom domain is essential. You can't promote your project using cloud service provider domains like vercel.app - these won't get favorable treatment from Google or SEO strategies, and users won't trust such domains enough to make payments.

You can use tldx (domain search tool), an open-source project, to search for a suitable domain that fits your product.

Then purchase a domain through Cloudflare Domains. .com domains cost around $10.

If you want cheaper options, you can choose platforms like Spaceship or regery. These platforms generally offer cheaper first-year pricing for certain domains.

I personally recommend buying domains directly from Cloudflare. Prices don't fluctuate much year to year, so you won't see big differences between first and second-year pricing. Plus, Cloudflare's DNS resolution is very fast, and since you'll likely need Cloudflare CDN and caching features anyway, choosing Cloudflare domains is hassle-free.

Email Services

Email services aren't mandatory. If your login/registration features already use third-party services like Clerk or only offer social login, you can skip email services.

If you need newsletter functionality or email marketing, you can choose email services like Resend or plunk (email marketing platform), which are very easy to integrate.

While these services might seem expensive, in practice, the per-email cost is actually reasonable. You typically don't send as many emails as you might imagine, and email delivery stability is very high - you won't face the blocking issues that come with self-hosted email sending.

If you have a system that heavily depends on email services, you'll need to consider services like AWS SES, which is much cheaper but requires handling various scenarios yourself.

Alternatively, for self-hosted deployment, you can consider using Unsend (an open-source alternative to Resend) + AWS SES (email delivery service).

Payment Platforms

For indie developers, payment platforms are essential - after all, how can you continue developing and paying server costs without revenue?

While payment platforms like Creem.io and Lemon Squeezy have become popular recently and are tempting for indie developers (since they don't require setting up overseas companies or handling complex tax issues), I still want to recommend mature, stable payment platforms like Stripe and Paddle first.

Platforms like Stripe are more mature with better ecosystems, easier withdrawals and settlements. Once you successfully set up Stripe or similar mature platforms, you'll rarely need to consider switching or dealing with hassles.

Final Thoughts

Finally, this article is written for indie development newcomers who want to try and see if they can successfully start their indie development journey.

Initially, I actually disliked terms like "budget stack" because this kind of language and technical approach can easily lead people into endless tinkering - constantly comparing prices across different platforms and investing time and energy into learning and fiddling with various platforms.

This tinkering goes against the indie development spirit. The indie development spirit is about rapid iteration, fast experimentation, quickly finding user needs, quickly finding product-market fit, quickly finding profitable business models and enabling payments - investing significant time in marketing and market activities. Not spending time and energy comparing different platform prices and learning various technologies.

But on the other hand, after chatting with fellow developers, plus having a frugal mindset myself, costs are a major concern for most people. Most people don't want to lose a lot of money on indie development.

That's why I spent a lot of time writing this blog post.

But if you have the financial ability to experiment, I still strongly recommend using a standard tech stack and corresponding platforms. Don't tinker or spend time on unnecessary things - put more energy into your product and marketing!

That's why my latest project NextDevKit aims to help indie developers quickly build complete Next.js projects and deploy them rapidly to different platforms. For example, NextDevKit supports three different templates that can be deployed with one click to Vercel, Cloudflare, Dokploy, AWS, and other platforms.

Let everyone spend their time and energy on products and marketing, not on technology and platforms.

In the past two weeks, I've also added support for Creem.io payment platform, Admin management dashboard, Chinese documentation, and more. I hope NextDevKit can help more indie developers succeed.