If you ever decide to build your own full‑scale (full‑stack) project — SaaS app, hobby project, pet project, whatever — think about what I’ve used here and consider whether it might fit your case too.

Now, before we dive in, here’s the context: I’m mostly a frontend guy with React. That obviously shapes my opinions. Technically, you can “cut out” some pieces and replace them with your own preferences (React vs Vue vs Angular, etc.). The main idea is simple: keep the stack lean, fast, and friendly for a solo developer. You want fast iteration, minimal time wasted on bullshit, and more time spent on “product” and “value” for your end user.

I’m not touching the “what product to build” topic here — this is purely about tech design choices. But keep in mind: most SaaS apps are either B2B or B2C. Know who you’re building for before you start.

And yes, I use AI/LLMs a lot. Even this article was proofread by an LLM (so you get higher‑quality text), but the content is mine — my experience, my opinions, my scars. Using LLMs multiplies your output. Not using them means you’re simply slower than everyone else.

Back to tech design

When I started building my SaaS product, I had the same trade‑offs every engineer has. You choose one thing over another. In my case, I knew I was doing this part‑time (because I work full‑time like most people), I knew React, TypeScript, MUI, and a bunch of other tools. Some things I’d be using for the first time — scary, but that’s how you learn. Some things I replaced with “new and better” options even though I was comfortable with the old ones. Example: Zod + RHF instead of Formik + Yup. I had tons of experience with Formik/Yup, but RHF + Zod is simply better today. So I picked the modern tooling, even if it meant learning something new. LLMs help a lot here.

I needed tools I already knew, while confirming they’re still modern, supported, secure, and easy to integrate with React.

After many, many discussions with different LLMs, here’s what I picked:

Frontend

Modern mobile‑first design, ReactJS, RHF, Zod, TypeScript, MUI, TanStack React Query, Zustand

• Mobile‑first — I needed mobile access for users. Responsive design is mandatory. I didn’t have time to build a dedicated native mobile client (maybe later with React Native, or maybe never).
• ReactJS — obvious. I know it well, it fits everything else I use. But you can swap it for Vue, Svelte, Angular, whatever. Once you know React deeply, switching to another modern framework is not a big deal. I use Vue at work — it’s fine. LLMs help.
• RHF (React Hook Form) — best in class today. Works beautifully with React, Zod, and TypeScript. I used Formik a lot before, but RHF is simply better.
• Zod — modern, trusted, works for both FE and BE validation. Replaces Yup perfectly. Native to TypeScript.
• TypeScript — I’m not a huge fan, but I use it everywhere because types matter. LLMs sometimes suck at TS (they love throwing any like little gremlins), so you must review code. TS is mostly about types; everything else… fuck it, leave it to TS fanatics. Also, I hate when interviews rate you on “deep TS knowledge.” How does that help business delivery? It doesn’t. It’s nitpicking.
• MUI — I’ve used it since v4. Still great. Tailwind is cool, but you still have to build your own components. MUI gives you ready‑made components, which is critical for solo dev speed. Styling used to be painful, but with LLMs it’s trivial now. Just make sure your LLM sticks to your theme — they tend to forget.
• TanStack React Query — I used classic Redux before. Then Redux Toolkit. But React Query is simply the best for server state. Most SaaS apps are server‑state heavy anyway. For FE state, use Zustand or Redux. I skipped Redux entirely — not because I don’t know it, but because I want simpler, faster tooling.
• Zustand — I debated between Redux and Zustand. LLMs sometimes say Zustand doesn’t scale well. But honestly… most solo devs never hit that scale. You’ll be lucky to hit your first 100 users. I picked Zustand. Funny enough, I barely use it — almost everything is server state handled by React Query.

Backend

Next.js, TypeScript, tRPC, Supabase, Stripe

• Next.js — tightly coupled with React, perfect for monorepos, and Vercel gives you a generous free tier. Some people say “Next.js is frontend, not backend.” That’s bullshit. It’s Node.js underneath. Node.js is backend. End of story.
• TypeScript — even more important on the backend.
• tRPC — if you haven’t used it, google it. In short: RPC with TypeScript. FE and BE share types. No string‑based API endpoints. No typos. Zod handles validation. It’s beautiful. Bonus: if your FE needs to call 3–5 endpoints, tRPC bundles them into one request. Faster UX, cleaner code.
• Supabase — absolute monster. Postgres in the cloud, Auth, Storage, and more. Generous free tier. Amazing for solo devs. Even paid tiers are cheap. If you need NoSQL, you can pick something else, but Supabase gives you so much out of the box that it’s hard to beat.
• Stripe — if you deal with money, Stripe is the standard. Billing, subscriptions, test environments, sandboxes — everything is there. Takes time to learn, but it’s worth it.

Testing

Playwright, Vitest

• Vitest for component tests, routers, logic.
• Playwright for E2E — takes time, but it’s the leader.
• Testing as a solo dev is tricky: “Did I break something?” “Can I trust my tests?” LLMs hallucinate, so review everything manually. Manual flow testing is still king.

Build & Deploy

Vercel + Supabase

As mentioned earlier — fast, simple, generous free tiers. Perfect combo.

Monorepo and Bundler

Turborepo and Turbopack

Next.js moved away from Webpack (thank god). Turbopack is better for local dev, still not perfect, but good enough. I haven’t needed deep monorepo tooling yet, but it’s there. Haven’t used Turborepo yet, will update once do.

Monitoring & Analytics

Vercel Analytics, Sentry, PostHog

• Vercel + Supabase give you built‑in analytics.
• Sentry for error tracking — absolutely essential.
• PostHog for product analytics — what features users actually use. Like Google Analytics but built for SaaS.

Other pieces

• Docs — Markdown inside the repo. Simple and perfect.
• Emails — Resend or SendGrid.
• Future mobile app — React Native.
• Feature flags — simple object or LaunchDarkly.

Final thoughts

It’s insanely easy to get stuck in tiny details — how RHF works internally, how Stripe webhooks behave, how TypeScript infers some obscure type. That’s procrastination disguised as “engineering.”

Your job as a solo dev is to ship imperfect things fast, get real users, and iterate. Don’t spend two years polishing something nobody wants. Pick a stack that lets you move at maximum speed. Avoid rituals from big companies — tickets, sprints, endless design docs. Focus on the core value for your users. Everything else is noise.

Good luck on your journey, folks.

Share your own stack and what you’d pick for yourself.

Cheers, Your DevUnwind guy