My Stack for ResumeOrbitz: React, Supabase, Netlify, and Why

One person, zero servers to babysit.

This is every tool behind ResumeOrbitz, a free AI resume builder, and the one choice I'd change if I started today.

New here? Start with the backstory: How I Built an AI Resume Builder as a Solo Founder in India.

The constraint decided everything

I'm the only engineer, designer and marketer. So every tool had to pass three tests:

• Ship fast: a stable version in weeks, not months
• Low budget: free tiers first, paid only when it saves real time
• No ops: if it needs a server I have to patch, it's out

Every choice below falls out of those three rules.

The stack at a glance

Layer	Tool	Why	Cost / month
Frontend	React + TypeScript + Vite	Stateful editor, fast builds	Free
Styling	Tailwind CSS	Styles live next to each template	Free
Auth + database	Supabase	Postgres, auth and row-level security in one	Free tier
Hosting	Netlify	Push to deploy, no servers	Free tier
Analytics + SEO	GA4, Search Console, JSON-LD, llms.txt	Free and good enough	Free
AI	Groq API	Fast responses, free tier	Free tier
Pair programmer	Claude Pro	One assistant that holds the whole problem	Pro plan (building only)

Frontend: React + TypeScript + Vite

A resume editor is a stateful UI. You type on the left and the preview updates on the right. React's component model fits that well, and its ecosystem meant I never had to build a basic widget myself.

TypeScript earns its place because a resume is a deeply nested object: sections, then entries, then bullets. Rename one field and the compiler shows every place that breaks, before a user finds it.

Vite keeps the loop short: the dev server starts in seconds, and hot reload shows a template change the moment I save.

Styling: Tailwind CSS

With 150+ templates, CSS can turn into a mess fast. Utility classes keep each template's styles next to its markup, so changing one template doesn't quietly break another.

Tailwind also strips unused classes at build time, so 150+ templates don't mean a huge CSS file.

Backend: Supabase for auth, data and storage

Supabase gave me Postgres, auth and row-level security without writing a backend. Saving a resume is one call from the frontend:

const { error } = await supabase
  .from("resumes")
  .upsert({
    id: resume.id,
    user_id: user.id,
    data: resume,
    updated_at: new Date().toISOString(),
  });

The part that makes this safe is a row-level security policy, so a user can only ever touch their own resumes:

create policy "Users manage their own resumes"
on resumes for all
using (auth.uid() = user_id);

With that policy in place, even a bug in the frontend can't hand one user another user's resume.

Hosting: Netlify

Git push, and it's live. Every branch gets a preview URL, which is handy for testing a template before it ships.

The one file every single-page app on Netlify needs is public/_redirects:

/*    /index.html   200

Without it, refreshing any page other than the home page returns a 404.

SEO in a single-page app

Google Analytics only counts the first page load in an SPA. This small hook records every route change as a page view:

import { useEffect } from "react";
import { useLocation } from "react-router-dom";

export function usePageTracking() {
  const location = useLocation();

  useEffect(() => {
    window.gtag?.("event", "page_view", {
      page_path: location.pathname + location.search,
      page_title: document.title,
    });
  }, [location]);
}

On top of that:

• A JsonLd.tsx component, wired into App.tsx, adds JSON-LD schema (including FAQPage) to each page
• Open Graph tags, so shared links show a proper preview
• An llms.txt file that tells AI assistants what the site does
• Google Search Console from early on

AI: Groq

Groq runs the AI behind ATS scoring, keyword gap analysis and cover letters. I picked it for two reasons: responses come back fast enough to feel instant inside the editor, and its free tier covers what a solo product needs right now.

The trade-off is rate limits on the free tier. That's a good problem to have, and one I'll solve when usage forces it.

What I'd change

I'd start with pre-rendering or SSR. A single-page app hands search engines an almost empty HTML shell until JavaScript runs. For a product that lives on organic search, every SEO fix since (JSON-LD, the page-view hook, llms.txt) has partly been a workaround for that one early choice.

If I started today, landing pages would ship real HTML from day one.

What it costs per month

₹0 to run. Supabase, Netlify, Groq, GA4 and Search Console are all on free tiers. The only paid tool is my Claude Pro subscription, and that's for building, not running.

Your turn

What's your stack for solo projects, and what would you swap? I read every comment.

Disclosure: I'm the founder of ResumeOrbitz, the tool this post is about.