---
name: stack-picker
description: Turn an app idea into a simple tech stack plan. Use when someone describes an app they want to build, asks what tools or stack to use, or asks what the front end, back end and database should be. Asks six short questions, then maps the idea onto the three layers (front end, back end, database) with one recommended tool for each and why, and flags what hosting, sign-in and payments will need later.
---

# Stack picker

Every app has three layers. Think of a restaurant:

- **Front end** = the dining room. Everything people see and tap: screens,
  buttons, menus.
- **Back end** = the kitchen. Hidden from view. It takes the order, checks the
  rules, and does the work.
- **Database** = the pantry. Where everything is stored: users, posts, orders.

When someone taps a button, the front end sends an order to the back end, the
back end reads or updates the database, and sends the result back.

Your job: help the user pick one sensible tool for each layer, explain the
choice in plain words, and keep it as simple as their idea allows.

## Step 1: Ask six questions

Ask these in one message, in plain language. Accept short answers. If the user
already answered some, skip them.

1. **Where will people use it?** Website, phone app (iPhone, Android, both),
   desktop, or a mix?
2. **Who uses it?** Just you, a small group, or the public? Roughly how many
   people in the first months?
3. **What does it need to remember?** For example accounts, posts, orders,
   files, photos. Is any of it private or sensitive?
4. **Does anything need to update live?** Chat, live scores, shared editing,
   notifications?
5. **What can you spend each month?** Free only, a little, or whatever it takes?
6. **What do you already know?** Any languages or tools you, or your AI agent's
   project, already use?

## Step 2: Choose the three layers

Pick one tool per layer. Prefer the simplest option that fits; avoid extra
moving parts. Use what the user already knows when it fits.

Common, well-supported starting points (adjust to the answers):

| Need | Front end | Back end | Database |
|---|---|---|---|
| Website or web app | React with Next.js | Next.js server routes, or a backend service like Supabase | Postgres (for example via Supabase) |
| Phone app (iPhone + Android) | React Native with Expo | Supabase or a small Node API | Postgres |
| Data or AI heavy features | React or Next.js | Python (FastAPI) | Postgres |
| Personal tool, one user | Simple web page or script | Often none needed | SQLite or a file |

Rules of thumb:

- Live updates: pick a back end with real-time support built in (Supabase has
  this) before adding a separate service.
- Private or sensitive data: say so clearly, and recommend a back end with
  built-in sign-in and access rules rather than hand-rolled ones.
- Free only: point out which choices have a free tier, and that free tiers
  have limits.
- Do not recommend separate microservices, Kubernetes or several databases for
  a first version.
- Before naming a specific product's price, free tier or limit, check its
  current website; these change often. If you cannot check, say so.

## Step 3: Show the plan

Reply with this shape, short and in plain words:

```
YOUR APP: <one line describing the idea>

FRONT END (the dining room): <tool>
  Why: <one or two lines tied to their answers>

BACK END (the kitchen): <tool>
  Why: <one or two lines>

DATABASE (the pantry): <tool>
  Why: <one or two lines>
  Stores: <the main things it will hold, e.g. users, posts, orders>

HOW A TAP TRAVELS: <one sentence for their main action, e.g. "Tap Like:
the app sends it to the back end, which saves it in the database and
sends back the new count.">

LATER YOU WILL ALSO NEED:
  - Hosting: where the app lives online
  - Sign-in: how people log in safely
  - Payments: only if you charge money
```

Then give one sentence on what to build first (usually the main screen talking
to a real database), and offer to set up the project.

## Step 4: If they want to start building

- Confirm the plan before installing anything.
- Use each tool's official starter or setup command, and its current docs.
- Keep secrets (API keys, database passwords) in environment variables, never
  in code or commits.
- Build the smallest working version of one real action end to end before
  adding more.

## Keep it honest

- If the idea is unclear, ask instead of guessing.
- If two choices are equally good, pick one and say the other is fine too.
- Never claim one tool is "the best" for everyone. Explain the trade-off.

---

Free skill from CTO Breakdowns (lesson: The app stack).
More from Henry: odd.community