Free · No email required

8 projects worth building, and what each one actually teaches you

Everyone tells you to build projects. Nobody tells you what you'll walk away knowing. So here's the list I wish I'd had, with the specific skill behind each one and how to build it without paying for anything.

Read this first

Why the todo app stopped working

A working app used to be expensive to produce. That cost was the proof — it took you two weeks, so you must have learned something.

AI can scaffold a todo app in twenty minutes. So the app itself no longer proves anything. What proves something now is being able to explain why you made each decision, and what broke along the way. Build things where the hard part isn't the code.

One finished project beats four abandoned ones

Half-built repos are a real problem in interviews — people will ask why you stopped, and "I got bored" is a bad answer. Pick one from this list. Finish it. Deploy it. Then pick the next.

Everything here is free to build

No project on this list requires money, a company, or a credit card. Where a service is normally paid, I've noted the free way to do it. That includes payments — see project 1.

The projects

1

A booking app with real payments

Something people reserve a slot for. A salon, a tutor, a padel court. Users pick a time, pay a deposit, get a confirmation. The interesting part isn't the calendar — it's everything that happens when the payment doesn't go smoothly.

What it teaches you
  • Authentication — sessions, protected routes, who is allowed to see whose bookings
  • Webhooks — your server reacting to an event that happens somewhere else, at a time you don't control
  • Idempotency — the webhook fires twice, and you must not charge twice or create two bookings
  • Failure states — card declined, insufficient funds, user closes the tab mid-payment. This is the part nobody teaches and everybody hits
  • Race conditions — two people booking the last 3pm slot at the same second
How to build it free
Stripe test mode. No business, no verification, no real card. Use test numbers: 4242 4242 4242 4242 succeeds, 4000 0000 0000 0002 gets declined. Run stripe listen to forward webhooks to localhost. The whole flow works end to end.
Stack
Next.js + Supabase + Stripe test mode
2

A scraper that runs on a schedule

Pick a site with data you actually want. Job listings, prices, football fixtures. Pull it every day, store the history, notice when things change. The project isn't finished when it works once — it's finished when it survives the site changing.

What it teaches you
  • Cron jobs and scheduling — code that runs when you're asleep
  • Rate limiting and backoff — how not to get IP-banned on day one
  • Retries — the request failed. Try again, but not immediately, and not forever
  • Data integrity — don't insert the same row twice when the job runs again
  • Alerting — knowing it broke at 3am, instead of finding out a week later
  • Schema drift — the site changed their HTML and your selector is now pointing at nothing
How to build it free
GitHub Actions gives you free scheduled runs. Supabase free tier for storage. Cheerio or Playwright to parse.
Stack
Node + Playwright + GitHub Actions + Postgres
3

Make something slow, fast

Take an app you already built, or any open-source one. Measure how slow it is. Make it faster. Publish the before and after numbers. This is the only project on the list where the README is the deliverable.

What it teaches you
  • Profiling — finding the actual bottleneck instead of guessing at it
  • Database indexes — why one query takes 2 seconds and the same query takes 8ms
  • The N+1 problem — the single most common performance bug in web apps
  • Caching — what's safe to cache, for how long, and how to invalidate it
  • Measuring honestly — including the changes that made no difference
How to build it free
Chrome DevTools, Lighthouse, and EXPLAIN ANALYZE in Postgres. All free, all built in.
Stack
Anything you've already built
4

A tool for a group you're actually part of

Your class, your gym, your gaming group, your family. Something small they genuinely need. The value here is unfakeable: real people using it and complaining at you when it breaks.

What it teaches you
  • Requirements from humans — people describe what they want badly, and you have to translate it
  • Scope negotiation — saying no to feature seven so feature one actually ships
  • Real error handling — users do things you never imagined, immediately
  • Deployment and uptime — it breaking matters now, because someone will tell you
  • Iteration — shipping v2 because v1 was wrong in ways you couldn't predict
How to build it free
Vercel + Supabase free tiers handle a real user base of this size comfortably.
Stack
Whatever you know best. Speed matters more than stack here
5

An AI feature where the hard part is the failure handling

Not a ChatGPT wrapper. Something that uses a model and stays useful when the model is wrong, slow, or returns nonsense. That distinction is the whole project.

What it teaches you
  • Structured output — forcing the model to return JSON that matches a schema, and validating it
  • Streaming — tokens arriving one at a time, and a UI that handles being cancelled halfway
  • Evals — a test suite for something non-deterministic. Genuinely rare, and the reason most people can't tell whether their last prompt change made things worse
  • Cost and rate limits — caching, batching, cheap model for easy calls and expensive for hard ones
  • Graceful degradation — what the user sees when the model is down
How to build it free
Groq's free tier: no credit card, 14,400 requests a day, fast. Google AI Studio also has a free tier.
Stack
Next.js + Groq + Zod for schema validation
6

A real-time anything

Live scores, a shared whiteboard, a multiplayer game, a queue display. Two browsers open, one changes, the other updates instantly. Simple to describe, full of edge cases.

What it teaches you
  • WebSockets — a connection that stays open, versus request-and-response
  • Optimistic UI — showing the change before the server confirms, and undoing it if the server says no
  • Reconnection — the user's wifi drops. What happens to the messages they missed?
  • Conflict resolution — two people edit the same thing at once
  • State sync — keeping the server and every client agreeing on the same reality
How to build it free
Supabase Realtime on the free tier, or plain WebSockets on Railway/Render free plans.
Stack
Next.js + Supabase Realtime
7

A migration between two systems that don't agree

Move data from one shape into another where the models genuinely conflict. A CSV export into a proper relational schema. One API's format into another's. The interesting work is the 3% of records that don't map cleanly.

What it teaches you
  • Data modelling — why the shape of your tables decides what's easy later
  • Lossy mapping decisions — this field has no equivalent. What do you do, and can you defend it?
  • Transactions — it failed at record 4,000 of 10,000. Now what?
  • Reconciliation — proving afterwards that nothing was silently lost
  • Dry runs — testing a destructive operation without destroying anything
How to build it free
Any public dataset plus a local Postgres. Kaggle and data.gov have plenty of genuinely messy real-world data.
Stack
Node or Python + Postgres
8

A developer tool you use every day

A CLI, a VS Code extension, a GitHub Action. Something that removes a small annoyance from your own workflow. Because you use it daily, you'll actually maintain it — which is the rarest signal on this whole list.

What it teaches you
  • Publishing packages — npm, semantic versioning, not breaking people who depend on you
  • CLI design — arguments, flags, sensible defaults, helpful errors
  • Writing docs for strangers — someone with none of your context has to use this
  • Backwards compatibility — you changed something and broke someone else's setup
  • Reading other people's code — if you extend an existing tool
How to build it free
npm publishing is free. GitHub Actions and the VS Code Marketplace are free to publish to.
Stack
Node + TypeScript

Before you call one finished

The project isn't done when it works on your laptop. These are the things that turn it from an exercise into something you can show someone.

1. Deploy it. A link someone can click beats a repo they have to run. Vercel, Netlify, Railway — all free.

2. Add demo credentials. If there's a login, put a test email and password in the README. Nobody is signing up to look at your project.

3. Write a README that answers three things in 60 seconds. What problem does this solve, what did you build it with, and what was the hardest part.

4. Document one decision you'd defend. Why this database, why this approach. This is what people ask about, and it's the thing AI can't produce for you.

5. Write down one thing that broke and how you fixed it. Interesting failures are more convincing than a clean build. Everyone knows nothing works first time.

6. Commit as you go, not all at once. A history that shows the thing growing over weeks says more than a single "initial commit" with 4,000 files.

7. Be able to explain every line. Use AI to build faster, absolutely. But if you can't explain what it wrote, you don't have a project — you have a screenshot.