In 2020, asking ten indie hackers about their tech stack produced ten different answers. Every combination of cloud provider, database, auth solution, and framework was represented.
In 2026, asking the same question produces remarkable consistency. The stack has converged. Not because a standards body decided anything, but because the right choices became clearer as the tools matured -- and because the cost of choosing wrong became visible in the form of migration pain, capability gaps, and price changes that forced founders to reconsider.
Here's what the current default stack looks like, what changed, and why.
The Framework: Next.js App Router Is Now the Default
Next.js with the App Router is the dominant choice for indie hackers building web apps in 2026. This wasn't inevitable two years ago -- the App Router was new, the documentation was rough, and many experienced founders were advising people to stick with Pages Router until the ecosystem caught up.
The ecosystem caught up. The App Router patterns are now well-documented, the third-party library compatibility issues that plagued early adoption are largely resolved, and the server components model has proven genuinely useful for the data-fetching patterns that indie hackers need most.
The meaningful alternative: if your product is a thick client application (primarily frontend state, real-time interactions, minimal server-rendered pages), Vite + React remains a strong choice. For simpler marketing sites and content-heavy products, Astro has matured into an excellent option that's worth considering before reaching for Next.js by default.
What's no longer the right choice for new projects: Create React App (officially deprecated), Pages Router for new projects that don't have a migration reason to avoid App Router.
The Database + Auth Layer: Supabase Won
If there is one category where the answer has become genuinely clear, it's the database/auth combination.
Supabase provides a hosted Postgres database, row-level security, realtime subscriptions, authentication (email/password, OAuth, magic link), file storage, and edge functions -- all with a generous free tier and a pricing model that scales reasonably for early projects.
In 2022-2023, the debate was still active: Firebase for real-time and mobile native feel, Supabase for SQL flexibility and open-source principles, PlanetScale for global scale from day one. PlanetScale eliminating their free tier in 2024 resolved the debate by forcing migration away. Firebase remains viable for certain mobile-native products, but its web SDK overhead and the cost structure at scale have pushed most indie hackers toward Supabase.
When to use Clerk instead: If your product requires enterprise SSO, complex organization structures (multi-tenant with role management), or passkeys out of the box, Clerk's auth-focused tooling is worth the additional cost over Supabase Auth. Clerk's prebuilt components are also meaningfully ahead of Supabase's auth UI for founders who want to ship an auth flow quickly without building forms.
The serverless Postgres alternative: Neon has matured significantly and is worth considering if you specifically want serverless Postgres with branching workflows. For most indie projects, Supabase's convenience advantage over Neon is still meaningful.
The ORM: Drizzle Is Replacing Prisma
This is the most notable shift in the developer layer. For several years, Prisma was the default ORM for TypeScript projects. In 2025-2026, Drizzle ORM has significantly eroded that dominance among indie hackers.
The reasons: Drizzle is lighter, faster to query, more SQL-transparent (the queries you write look like SQL, not like an abstraction on top of SQL), and its schema definition and migration workflow are explicitly designed for the patterns indie hackers use. The bundle size difference matters for edge deployments.
Prisma is not wrong. It's still well-supported and its developer experience for complex relational queries is strong. But for new projects, Drizzle is worth considering as the default rather than the alternative.
The Email Layer: Resend + React Email
Resend has become the transactional email provider of choice for indie hackers, replacing the fragmented combination of SendGrid (enterprise-priced), Mailgun (API first but harder to use), and Postmark.
The combination of Resend with React Email -- a library for writing email templates as React components -- is now the default for founders building in the Next.js ecosystem. It allows email templates to be written and previewed in the same environment as the rest of the product, without the separate template editor and export workflow that legacy email tools require.
For newsletter/marketing email (as opposed to transactional): Resend Broadcasts is now available but still maturing. Beehiiv remains the dominant choice for newsletter content and audience management.
Payments: Stripe Still, But with Serious Alternatives
Stripe remains the default for most payment flows. The API quality, the documentation, and the ecosystem of Stripe integrations built into every tool and platform make it the safe choice.
What's changed: Lemon Squeezy and Polar have matured meaningfully as merchant-of-record alternatives that handle VAT/sales tax compliance globally. For indie hackers selling to consumers or small businesses across multiple countries, the merchant-of-record model (where the payment processor handles tax compliance) removes a significant compliance burden.
If you're selling a SaaS product with primarily US-based customers and straightforward billing, Stripe with Stripe Tax is probably sufficient. If you're selling globally from day one and don't want to think about VAT, Lemon Squeezy or Polar is worth the slightly higher fee.
The AI Integration Layer: Vercel AI SDK
For founders building AI-powered features into Next.js apps, the Vercel AI SDK has become the standard integration layer. It provides abstractions for streaming responses, chat history management, tool calling, and provider switching that remove the boilerplate that direct API implementation required.
The SDK is provider-agnostic -- it works with OpenAI, Anthropic, Google Gemini, and others through a consistent API. This matters because the right model for any given task has been shifting, and writing your integration against the Vercel AI SDK rather than directly against OpenAI's API makes switching or A/B testing models significantly easier.
For simple AI integrations where you're calling one model for one task, the overhead of the SDK is low and the convenience is real. For complex multi-agent or specialized AI workflows, direct SDK use is still appropriate.
The Deployment Layer: Vercel for Web, Railway for Backend
Vercel for Next.js deployments is the path of least resistance and the right choice for most indie projects. Preview deployments, the edge network, and the Next.js-specific optimizations are real advantages.
The cost concern that many founders raise about Vercel at scale is valid but often premature. At the stage most indie hackers are building -- under 100K monthly active users -- Vercel's pricing is reasonable. The migration to a different deployment platform, if it becomes necessary, is better addressed when that scale is actually reached.
Railway has matured as the right choice for backend services, cron jobs, PostgreSQL instances you want to run yourself, and anything that doesn't fit Vercel's model. Its pricing model is consumption-based in a way that suits projects with variable traffic better than Render's tier-based approach.
Cloudflare Workers and Pages remain excellent for edge-deployed functions and static sites where latency is critical. The Cloudflare ecosystem (R2 for storage, D1 for SQLite at the edge, KV for key-value) is increasingly cohesive and worth considering for specific use cases.
The AI-Assisted Development Layer: Cursor + v0
This is genuinely new since 2023 and has meaningfully changed what a solo founder can build in a given time.
Cursor (the AI-powered code editor) has become the primary development environment for a large and growing portion of indie hackers. The combination of tab completion that understand your codebase and inline code generation that can implement features from a description has compressed implementation time on routine tasks substantially.
v0 (Vercel's AI UI component generator) generates working shadcn/ui component code from text descriptions or screenshots. For founders without strong frontend design skills, this eliminates the blank-canvas problem for UI work.
The honest assessment: AI coding assistance does not eliminate the need for engineering judgment. Generated code has to be read, understood, and often refactored. But for the routine implementation work -- CRUD endpoints, auth flows, form handling, basic UI components -- the time compression is real. A solo founder using these tools effectively can now ship what previously required a two-person team.
The Analytics Layer: PostHog for Product, Plausible for Web
PostHog has emerged as the indie hacker's product analytics platform: feature flags, session recordings, funnel analysis, event tracking, and A/B testing in one open-source tool with a generous free tier.
For web analytics (page views, traffic sources, bounce rate) where you don't need product-level events: Plausible or Umami provide clean, privacy-compliant alternatives to Google Analytics without the cookie consent and data residency complexity.
What's No Longer Worth Starting Fresh With
- Firebase (for new web products -- Supabase is a more complete and predictable option unless you have mobile-specific reasons)
- Heroku (the pricing changes and platform stagnation have moved most indie hackers to Railway or Render)
- PlanetScale (free tier elimination and pricing model changes)
- Custom server configuration on raw EC2/DigitalOcean for most projects (the managed platforms have closed the capability gap)
- Redux for state management in most Next.js apps (server components and Zustand have replaced it for the majority of use cases)
The Default Indie Stack in 2026
For a new SaaS product started in early 2026, the default choices look like this in most cases:
| Layer | Default Choice | Alternative |
|---|---|---|
| Framework | Next.js App Router | Vite + React (thick clients) |
| Database + Auth | Supabase | Neon (serverless Postgres) + Clerk |
| ORM | Drizzle | Prisma |
| Payments | Stripe + Stripe Tax | Lemon Squeezy / Polar (global) |
| Transactional email | Resend + React Email | Postmark |
| Deployment | Vercel | Railway (backend), Cloudflare (edge) |
| AI features | Vercel AI SDK | Direct provider SDK |
| Product analytics | PostHog | Mixpanel |
| Web analytics | Plausible | Umami |
| Error monitoring | Sentry | Highlight.io |
| AI dev tooling | Cursor | GitHub Copilot |
This stack would have been unfamiliar or unrecognizable two years ago. Resend was new. Drizzle was emerging. The App Router was unstable. PostHog was less mature. V0 didn't exist.
The convergence is real and it's useful. Having a default stack means less time deciding what to use and more time deciding what to build.
That's the actual shift: the infrastructure decisions are settled enough that the founder's time goes to the product, not the plumbing.
Use the default stack unless you have a specific reason not to. Optimize the product, not the toolchain.
Ready to validate your idea?
Start using WarmLaunch today to grow your waitlist.