A stack is a set of slots, and every project fills the same ones. The arguing online is about which option goes in each slot, and almost none of that argument applies to one person trying to finish a side project. What decides your outcome is how much unstuck time you spend, and that depends more on how well documented your choices are than on how good they are.

The idea

Fix the slots first, then fill them. You need something to draw the interface, something to run code on a server, somewhere to keep data, something to handle accounts, and somewhere to run it all. Some options cover several slots at once, and for a solo builder that is worth more than any individual component being the best available. The you can finish beats the stack you can defend.

code
   SLOT                COMMON OPTIONS              GOOD AT
   ------------------------------------------------------------------------
   interface           React                       huge ecosystem, most
                                                   examples in existence
                       Svelte                      less code per feature,
                                                   simpler mental model

   framework           Next.js (React)             frontend + backend in
   (both halves)                                   one project, deploys easily
                       Ruby on Rails               conventions for everything,
                                                   very fast for CRUD apps
                       Django (Python)             mature, batteries included,
                                                   strong admin interface

   data + accounts     Supabase                    Postgres you own, auth and
                                                   storage included
                       Firebase                    realtime by default,
                                                   very little setup

   hosting             section 6, Shipping         picked last, changed easily
   ------------------------------------------------------------------------
   five slots: interface, server, data, accounts, hosting.
   four rows, because one option often fills two slots at once.

How it works

The interface layer draws what the user sees. React is the most widely used, which mostly means every question you have has already been answered somewhere. Svelte does the same job with less ceremony and fewer people to ask.

A full-stack covers the browser and the server in one codebase. Next.js is React on both sides and is built to deploy as one unit. Rails and Django are older and come with an opinion about everything. Django ships a working admin screen you get for free; Rails ships generators and migrations and leaves the admin panel to an add-on. For a data-heavy app either is a large head start.

Supabase and Firebase fill the data and accounts slots together. Supabase is Postgres, so what you learn transfers and you can leave. Firebase is Google's; its usual store, Firestore, holds documents rather than tables, and it handles realtime updates with almost no work.

Every one of these has shipped serious products, and this page names no winner. The criterion below will point you at popular combinations, because popular is what your assistant has read the most of. That is a fact about the tool, not a verdict on the software.

What to do

  1. Write the five slots down as five lines, interface, server, data, accounts, hosting, and put a name on each. If one choice covers two lines, write it twice. Ten minutes.
  2. Weigh how much public example code exists for the combination, because that is what your AI assistant learned from. A widely used pairing produces confident, current output. An unusual one produces plausible code that quietly uses an API which no longer exists, and you will spend your evenings finding out which.
  3. Prefer the option that fills two slots when you are working alone. Fewer moving parts is fewer things to debug at midnight.
  4. Then stop choosing and start building. The stack decision has a short half-life and the project does not.

Where it breaks

Bundles trade freedom for speed, and the bill arrives late. Firestore's data model is genuinely hard to leave once you have a year of documents in it, which is why "can I export this" is worth asking on day one. The AI-familiarity criterion also has a bias built in: it points at whatever was popular in the training data, and it will happily write you 2023's Next.js in a 2026 project.

One practical warning about the pages after this one. They need concrete filenames and commands to be worth reading, so they use Next.js, Postgres and Supabase throughout. If you filled your slots differently, the shape of every explanation still holds and the specific names will not match what is on your screen. Read them for the decision, then ask your assistant for the equivalent in your stack.

No stack saves a project from the actual failure mode, which is that nobody wanted the thing. That decision sits above all of this.