Indie Dev Thrifty Plan for the Web: Full-Stack Tech Stack and Platform Choices

To set the scope upfront: this article focuses on full‑stack web tech stacks and platform choices. If you’re into mobile, backend, or browser extensions, drop a like and follow—I can share those later.

Let me start by sharing my current full‑stack picks for solo web development on the Web.

Ecosystem-wise, there are many viable full‑stack options—Next.js, Nuxt, Laravel, Django, .NET Core, Ruby on Rails, and more.

Although there are quite a few things in Next.js 14 and 15 that I’m not thrilled about, at this moment Next.js remains my sole personal recommendation for a full‑stack framework.

Why? Because Next.js inherits the React ecosystem, which is still the most vibrant by far. Tons of open-source libraries and platforms—domestic and international—treat Next.js as a first-class citizen. That translates into two big advantages:

• Whatever platform you pick and whatever features you need, it’s simply easier to find libraries and documentation that just work.
• For AI and AI-powered IDEs, a rich ecosystem with thorough docs means AI-written code tends to be more accurate and less buggy.

This ecosystem “monopoly” effect feels even stronger in the AI era. New frameworks will have a harder time breaking out than before.

Next.js is also flexible across different needs—SSR, SSG, ISR, and more—covering most business scenarios.

Below is my concrete Next.js tech stack selection. While most choices are cost-agnostic, some do impose platform constraints.

For example, you might add email to your project and pick nodemailer—but that library isn’t supported on many edge platforms, like Cloudflare Workers.

After a lot of potholes and testing, here’s a platform-agnostic, battle-tested Next.js stack that can deploy almost anywhere and covers most SaaS needs:

• Database: Drizzle ORM
• Auth: Better Auth
• Payments: Stripe (processor) + Creem (emerging payment platform)
• Email: React Email + Resend (email delivery)
• Object Storage: S3 / R2
• Blog: MDX support with Fumadocs MDX
• Docs: Fumadocs with search
• i18n: next-intl
• Dark theme: next-themes
• Analytics: vanilla-cookieconsent + GA + umami (open source) + plausible (privacy-friendly)
• UI/UX: Tailwind CSS + shadcn/ui + Radix UI + Framer Motion
• State: Zustand + TanStack Query + React Hook Form
• Type safety: Full TypeScript + Zod validation
• Lint & Formatter: Biome

A few quick explanations for choices unrelated to cost:

• Database — Drizzle ORM: a very lightweight ORM with friendly types, supporting PostgreSQL, MySQL, SQLite, etc. Crucially, it outperforms Prisma and shines on edge platforms.
• Auth — Better Auth: a comprehensive auth library with Email/Password, Social Login, and a variety of plugins (e.g., Admin). The docs are clearer than Auth.js in my experience.
• Blog & Docs — Fumadocs: folks familiar with my open-source blog know I used to rely on content-collections for MDX management/rendering. Fumadocs gives you docs features (search, themes, rendering) and MDX management together, so I’ve been consolidating onto Fumadocs to cut dependencies and unify the stack.
• Lint & Formatter — Biome: instead of the default ESLint + Prettier combo, Biome’s Rust-powered performance is notably better, and its all‑in‑one nature simplifies config.

Clarify Your Needs and Costs

This "thrifty plan" targets products that earn money or plan to monetize—not personal or hobby projects.

• If it’s a personal project for you and friends, pick whatever tech and platform you love. Free tiers are generous—say Vercel + Neon. A private chatbot you use yourself will rarely hit Vercel’s free limits.
• If you’re building a paid product—or using a free product to build reputation and convert a portion of users—you must factor in costs.

Before we dive into line‑items, here are three broad approaches if you want to pursue a thrifty strategy for web development:

1. Free tiers from major cloud platforms (e.g., Supabase for BaaS, Neon for serverless PostgreSQL, Railway, Fly.io, Zeabur, etc.)

• Pros: $0 to start. No server maintenance or backups. Can handle future growth and traffic spikes.
• Cons: Free limits are finite; you’ll pay once you exceed them. Some platforms require credit card verification. Pricing can be steep after the free tier. Some free plans disallow commercial use (e.g., Vercel’s free plan explicitly forbids commercial projects).

2. Go all‑in on Cloudflare.

• Pros: Developers in China call Cloudflare the “cyber bodhisattva.” Free CDN, and compute/storage/logs are cheap and abundant. Pay ~$5/month and stop worrying about traffic and bandwidth.
• Cons: You’ll need at least ~$5/month to get going seriously. The completely free tier isn’t robust and has more limits. Community support can be patchy; there are gotchas you’ll have to discover.

3. Self‑host on a budget VPS/VM with solid open-source PaaS options (e.g., Dokploy, Coolify).

• Pros: Fully customizable, high freedom, low cost. Besides your app, you can host PostgreSQL, Umami (analytics), Unsend (email), etc.—one box to rule them all.
• Cons: You maintain servers. High time cost. You must plan for stability, security, backups, monitoring, logs, and scaling.

Cloud Platforms (Free‑Tier Approach)

If you want truly $0 to start, you’re looking at free tiers across providers—or a startup program with AWS/Azure/Google Cloud (not covered here).

Here are some recommended platform combos:

Suggested Combinations

Entry-Level (completely free):

• Deploy: Vercel (non‑commercial projects)
• Database: Supabase or Neon
• Auth: Clerk (or roll your own with Better‑Auth)
• Storage: Cloudflare R2
• Email: Resend
• Monthly cost: $0 (within free limits)

Stable Operations (small commercial projects):

• Deploy: Vercel Pro
• Database: Neon
• Auth: Clerk Pro
• Storage: Cloudflare R2
• Email: Resend Pro
• Payments: Stripe or Creem
• Estimated monthly cost: $25–100

Below are some notable free‑tier quotas you can reference.

Deployment Platforms

Vercel

• Free tier:
  • 100 GB bandwidth / month
  • 4 CPU‑hours / month
  • 1M edge network requests / month
  • Custom domains supported
• Paid: Pro $20/month
• Pros: Official Next.js support, fast deployments, global CDN, great DX—the standard Next.js platform.
• Cons: Free tier disallows commercial use. Pricing can be complex; if you don’t optimize, surprise bills can hit hard.

Zeabur

• Free tier:
  • $5 trial credits
• Paid: Pro from $5/month
• Pros: Pay‑as‑you‑go, low starting cost, container deployments. As traffic grows, you can buy servers directly on-platform and keep the same DX. Can deploy DBs, Redis, Next.js apps, and even host your own machines.

Railway

• Free: $5 monthly credits during trial; legacy users get $5 every month; after that pure pay‑as‑you‑go
• Pricing: pay by resource usage
  • ~ $0.000463/GB‑hour (memory)
  • ~ $0.000231/vCPU‑hour
  • ~ $0.000000047683716/KB bandwidth
• Pros: Flexible PaaS supporting many languages/frameworks. Can deploy PostgreSQL and Docker containers. Easy to use.
• Cons: Can be pricey for small projects; costs can ramp fast with traffic.

Fly.io

• Free policy: bills under $5/month may be waived (unofficial; subject to change)
• Pricing: shared‑1x 256MB ≈ $1.94/month; performance CPUs cost more
• Billing dimensions: compute time, memory, storage, bandwidth
• Pros: Global deployment for apps; supports many languages and Docker.
• Cons: That “small free” policy could change anytime.

Database Platforms

Supabase

• Free:
  • 500 MB database storage
  • Up to 2 projects
  • 5 GB bandwidth
• Paid: Pro $25/month (includes 8 GB DB, 100 GB bandwidth)
• Pros: Open-source BaaS: PostgreSQL, realtime, built-in auth, file storage.
• Cons: Limited free storage; complex queries can impact performance.

Neon

• Free:
  • 0.5 GiB storage
  • 10 projects
  • 10 branches
  • 190 compute hours / month
• Paid: Launch $19/month, Scale $69/month
• Pros: Serverless PostgreSQL, branching, easy scaling.
• Cons: Free storage is small; compute hours limited.

Upstash (Serverless Redis/Kafka)

• Free:
  • 10,000 requests/day
  • 256 MB memory
• Paid: Pay‑as‑you‑go $0.2 per 100k requests; fixed plans $10–280/month
• Pros: Serverless Redis/Kafka at the edge, global, pay‑as‑you‑go.
• Cons: Free request limit is tight; fixed plans can be pricey for tiny projects.

Auth

Clerk

• Free:
  • 10,000 monthly active users
  • All auth methods (email, social, etc.)
  • Basic user management
• Paid: Pro $25/month (50,000 MAU), Enterprise custom
• Pros: Great DX, rich UI components, many auth flows.
• Cons: Comparatively pricier; third‑party dependency.

Object Storage

Cloudflare R2

• Free:
  • 10 GB storage / month
  • 1,000,000 Class A operations (writes) / month
  • 10,000,000 Class B operations (reads) / month
  • No egress bandwidth fees
• Paid:
  • $4.50 / million Class A operations
  • $0.015 / GB storage
• Pros: No egress fees, S3‑compatible API, inexpensive, global CDN.
• Cons: Slower access from Mainland China; none abroad.

Email Services

Resend

• Free:
  • 3,000 emails / month
  • 100 emails / day
  • API & SDKs
• Paid:
  • Pro $20/month (50,000 emails)
  • Scale $85/month (100,000 emails)
• Pros: Dev‑friendly, modern API, templating, strong deliverability.
• Cons: Free quota is relatively small; newer platform, stability still maturing.

Summary

Starting with cloud free tiers has obvious upsides: no need to reinvent the wheel for newsletters, email delivery, login/registration, etc. No server ops—just pick stable, managed services and focus on your product.

The flip side is once traffic increases and you blow past free limits, costs can spike quickly. Vercel bills hitting hundreds or thousands of dollars per month aren’t unheard of on Reddit.

If you choose this model, be deliberate from day one about traffic and cost modeling. Have a business model and revenue plan ready. Otherwise, a project where costs consistently exceed revenue is hard to sustain.

That said, don’t over-worry about the “what if traffic explodes” boogeyman. Realistically, most indie projects won’t see users or traffic for a while. As long as people are paying you, you cap free features, and you optimize Next.js—lean more on Edge Functions, avoid heavy Image Optimization—then building a project with revenue > cost on cloud free tiers is quite achievable.

I still recommend this approach for many: focus on product, spend more time marketing and less wrangling third-party services and infra. That’s the indie spirit.

All‑In on Cloudflare

The second approach is to go all‑in on Cloudflare. It fits three scenarios especially well:

1. You have enough technical foundation and don’t mind tinkering a bit.

2. You’re running high‑traffic, zero‑revenue projects to build reputation and convert users later.

3. You want the best cost‑effectiveness and don’t want to worry about traffic bills.

I think all three can fit the ALL‑IN Cloudflare route. Cloudflare’s pure free tier isn’t stable enough for serious commercial use (e.g., Workers CPU time limits), but the $5/month plan bundles many services—Workers + KV + D1 + R2 + more. For a SaaS or content site, that’s compelling.

Here are some Cloudflare services and quotas to consider.

Workers (Compute)

Cloudflare Workers

• Free:
  • 100,000 requests/day
  • ~10 ms CPU time per request
• $5 plan includes:
  • 10 million requests/month, +$0.30 per additional million
  • 30 million CPU ms/month, +$0.02 per additional million CPU ms
• Pros: No bandwidth/egress fees. No scaling headaches. Inexpensive.
• Cons: CPU time limits; not a standard Node.js environment—some patterns need special handling.

D1 (Database)

Cloudflare D1

• Free:
  • 5 GB storage / month
  • Reads: 5 million / day
  • Writes: 100,000 / day
• $5 plan includes:
  • Reads: first 25 billion / month included, then $0.001 / million rows
  • Writes: first 50 million / month included, then $1.00 / million rows
• Pros: Cheap, no egress fees, fast, supports several ORMs.
• Cons: D1 is SQLite under the hood; for heavy write workloads, PostgreSQL is a better fit.

KV (Key‑Value Store)

Cloudflare KV

• Free:
  • Reads: 100,000 / day
  • Writes: 1,000 / day
  • 1 GB storage
• $5 plan includes:
  • Reads: 10 million / month, +$0.50 / million
  • Writes: 1 million / month, +$5.00 / million
  • 1 GB storage, +$0.50 / GB‑month
• Pros: Cheap, no egress fees, fast.
• Cons: Better suited for small/medium workloads; not ideal for very large projects.

Object Storage

Cloudflare R2

• Free:
  • 10 GB storage / month
  • 1,000,000 Class A ops (writes) / month
  • 10,000,000 Class B ops (reads) / month
  • No egress bandwidth fees
• Paid:
  • $4.50 / million Class A ops
  • $0.015 / GB storage
• Pros: No egress fees, S3‑compatible, inexpensive, global CDN.
• Cons: Slower from Mainland China; fine elsewhere.

Summary

Going all‑in on Cloudflare is what I’ve done for several projects. Collectively, they serve hundreds of thousands of visits per month—this blog you’re reading and the NextDevKit project included—and I still haven’t exceeded the $5/month plan.

Thanks to the OpenNext Cloudflare project, building a full‑stack Next.js app on Cloudflare is now straightforward, with seamless integrations for D1, KV, R2, and more.

And because Cloudflare’s CDN is among the rare truly global free CDNs, while Mainland China can be slower, for high‑traffic, overseas‑facing projects with smart caching, it’s an excellent choice.

Self‑Hosting

The third approach is to buy a VPS/VM and self‑host everything. The pros and cons are clear.

• Pros: Full control, full customization, low cost. One VM can host your app, database, email service, logs, analytics, and more. You’re not beholden to third‑party pricing or policies.
• Cons: You’re the ops team—stability, security, backups, monitoring, logs. When traffic ramps, you plan scaling: bigger boxes, migration, HA. Also consider resilience against DDoS/traffic attacks.

You can reduce toil with open-source self‑hosted PaaS like Dokploy and Coolify. For example, once you install Dokploy on a VM, you get one‑click templates, CI/CD container deployments, SSL management, automatic backups, scaling, and more.

Here are containerized services I commonly run on a Dokploy template:

• Analytics: Plausible (privacy‑friendly) + Umami (open-source, privacy‑friendly)
• Email: Unsend (an open‑source Resend alternative for self‑hosted email delivery)
• Databases: PostgreSQL + Redis
• Monitoring: Uptime Kuma
• Backups: Cloudflare R2
• Automation: n8n (open-source workflow automation like Zapier)

This model’s primary cost is your server(s). You can pick stable VMs from big providers, or hunt for cheaper VM hosts.

Other Costs

Beyond deployment, consider these additional costs.

Domains

An indie product needs a proper domain. You can’t seriously promote with provider subdomains (e.g., vercel.app). Search engines and SEO won’t favor them, and users won’t trust them for payments.

Use tldx (open-source domain search) to find a good name, then buy via Cloudflare Domains. A .com is roughly $10/year.

If you want cheaper registrars for year one, try Spaceship or Regery—they often discount certain TLDs. Personally, I recommend buying on Cloudflare: stable renewal pricing, fast DNS, and if you’ll use Cloudflare CDN/Cache anyway, it saves hassle.

Email Services

Email isn't strictly required. If you use a third‑party auth like Clerk or only offer social login, you may skip it.

If you need newsletters or email marketing, Resend or Plunk are easy to integrate. They may look pricey, but in practice the per‑email cost is fine—actual send volumes are often lower than you’d expect—and reliability is high, unlike many self‑hosted setups that risk getting blocked.

If your system is email‑heavy, consider AWS SES for much lower pricing, though you’ll handle more edge cases yourself. For self‑hosting, pair Unsend (open source) with AWS SES.

Payments

Indie devs need payments—no revenue, no runway.

Platforms like Creem.io and Lemon Squeezy have been getting attention because, for many devs in China, you don’t need an overseas company or to wrangle taxes. That’s tempting. Still, I recommend mature options like Stripe and Paddle first.

Stripe is more mature, with a robust ecosystem and smooth payouts. Once you’re up and running on Stripe, you rarely need to switch.

That said, many folks are early-stage: no product traction yet, uncertain income, and the idea of incorporating overseas and handling taxes is daunting. If that’s you, Creem.io can be a viable pick—but it’s newer, with less polish and community depth. Expect some gotchas.

Note: Lemon Squeezy, which I previously recommended on the blog, has not been accepting new users for a long time after Stripe’s acquisition.

Creem tips I’ve learned from indie devs who got payments and withdrawals working without incorporating:

1. Unlike Stripe—whose “gotcha” is easy sign‑up but strict payouts later—Creem is strict up front about product approval. Don’t casually fill in your product info and pricing. Their review ensures legal compliance; fail it and your account could be closed. If your product isn’t production‑ready, do not submit the Payout Account review. Use their official checklist to audit your site, descriptions, and compliance. If your product is lawful and you follow the checklist, approval is straightforward.
2. For withdrawals: although Creem supports Alipay, Alipay requires proof of income source. Creem’s current proof docs may not pass Alipay’s review. Consider withdrawing to Wise or a Hong Kong bank card instead—still cheaper than incorporating a company.

Wrapping Up

This article is for beginners setting out on an indie‑dev journey, testing whether they can get something off the ground.

I used to dislike “thrifty plans,” because they can lure you into endless tinkering—comparing platform prices, spending precious time learning every service instead of building and selling.

That’s the opposite of the indie ethos: iterate fast, fail fast, find user needs fast, find product‑market fit fast, find monetization and start charging fast. Pour time into marketing and distribution—not yak‑shaving infra and nickel‑and‑diming every platform.

On the other hand, after talking with many peers, costs really do matter—most of us don’t want to pour tons of 💰 into an indie project with nothing coming back.