# Where to Go Next

A look back at what you can now build with FastAPI, two projects to build on your own that put it all together (a tool library's API and an API of your own, online at a link), and how to choose a next step among a front end, PostgreSQL, SQLAlchemy, Docker and Django.

Journeyman · FastAPI · REST API · Updated November 19, 2026

By Gregor Dzierzon

## After this lesson you can

- Plan a FastAPI app of your own that meets every requirement on the course's list
- Choose a next step after Python Web APIs, such as a front end, PostgreSQL, SQLAlchemy, Docker or Django

## Key takeaways

- You can now build, check, store, secure, test and ship a REST API with FastAPI and SQLite, and put it online at a link.
- The best next project is an API of your own, with routers, field rules, SQLite, sign-in and roles, tests, CI, a README and a live link.
- A front end turns your API into an app people use, and PostgreSQL keeps an online API's data for real.
- SQLAlchemy writes SQL for you from Python classes, Docker packs an app to run the same everywhere, and Django builds whole websites with an admin.

This is the last lesson of the course. When you started, `@app.get` was new. Now a hiker at a trailhead can open a link to an API you put online. This lesson is for the moment you finish and ask "now what?": it looks back at what you can do, describes two projects that pull it all together, and helps you choose what to learn next, based on what you want to build.

## What you can do now

Here's the course, as things you can do:

- **Build an API with FastAPI:** routes, path and query parameters, a request body, 404s, routers and the docs page (Module 1).
- **Check every request:** Pydantic models with field rules, response models that choose what goes out, one error shape for every error, and tests with pytest and `TestClient` (Module 2).
- **Keep its data in SQLite:** hand-written SQL in one data module, related tables, joins, paging, migrations, and tests on a throwaway database (Module 3).
- **Secure it:** hashed passwords, sign-in with tokens, roles, CORS, rate limits and secrets kept out of the code (Module 4).
- **Ship it:** settings checked at startup, logs that never leak, a health check, async routes where they help, Ruff and mypy, tests on every push, and the API online (Module 5).

That's the back end of most apps you use every day. Anything you can't do yet is a next step, not a wall.

## Try it: a tool library's API

Lessons and exercises hand you the problem. Here's one with no step-by-step instructions: an API for a neighborhood tool library, where people borrow a drill or a ladder and bring it back. Keep it small on purpose, so the work goes into shipping it the professional way:

- settings checked at startup, logs with no secrets, and a `/health` route;
- Ruff and mypy clean, with pytest run by GitHub Actions on every push, and a status badge in the README;
- online with Render's free web service and demo data seeded at startup, at a link you can send to a neighbor.

There's no starter and no test suite for this one: you start from an empty folder, and when your own tests pass on every push, it works.

## An API of your own

The step after that is the one every back-end developer takes: an API you design and build yourself, from the idea up. Choose one of these, or bring your own idea of the same size:

- **Habit Tracker:** daily check-ins and streaks.
- **Recipe Box:** recipes, their ingredients, and a search.
- **Club Events:** a club of your own design and its events.

Whichever you choose, it needs all of these:

1. FastAPI with routers, and Pydantic models with field rules for every request.
2. SQLite with hand-written SQL in one data module, at least two related tables, and numbered migrations.
3. Sign-in with pwdlib and tokens, and at least two roles with different rights.
4. One error shape for every error.
5. End-to-end tests with pytest and `TestClient` on a throwaway database, with a test for each role.
6. Settings from the environment, logs with no secrets, and a `/health` route.
7. Ruff and mypy clean, and a CI pipeline on GitHub Actions.
8. A README that explains every endpoint, with a link to its `/docs` page.
9. The API online at a link.

Plan before you build: list what your API does, and beside each line, which of the nine it covers.

## Where to go next

There's no wrong order. Choose by what you want to build next:

| If you want to... | Go next to |
|---|---|
| Give your API pages people can use | A front end: a web page that calls your API with JavaScript |
| Keep an online API's data for real | PostgreSQL, a database server your API connects to over the network |
| Stop writing every query by hand in a big project | SQLAlchemy, which writes SQL from Python classes |
| Ship an app that runs the same on any computer | Docker, which packs an app with everything it needs |
| Build a whole website with pages, forms and an admin | Django, Python's other big web framework |

A **front end** is the part of an app people see and touch: pages that call your API and show its JSON as buttons and lists. The SQL you wrote carries over to **PostgreSQL** almost line for line, and **SQLAlchemy** is the ORM that *SQLAlchemy and SQLModel: When a Project Uses an ORM* taught you to read. **Docker** packs your API into a **container** that runs the same on your laptop and on a host.

On ask-codey.com, these courses are a good next step:

- **JavaScript in Depth:** the language a front end is written in, including calling an API like yours.
- **HTML in Depth:** the pages a front end is made of.
- **CSS in Depth:** how those pages look.
- **Data Structures and Big-O, Demystified:** how fast your code runs, and why.
- **Design Patterns, Demystified:** names for the shapes good code keeps taking.
- **Bash in Depth:** the terminal on a Mac and on most hosts.
- **PowerShell in Depth:** the terminal on Windows.

Whichever you choose, keep building: the quickest way to learn the next thing is a small project that needs it.

## Check yourself

2 questions to try on the lesson page.

## So what

You can build, secure, test and ship an API that real people use from their phones. The next tool you learn builds on that, and the projects you make with it are yours to show.

## Key terms

- [Front End](https://www.ask-codey.com/glossary/front-end)
- PostgreSQL
- Docker
- Django

## Related

- [Put Your API Online with Render](https://www.ask-codey.com/lessons/fastapi-deploy-render)
- [Exercise: Trail Conditions Online](https://www.ask-codey.com/lessons/exercise-fastapi-trail-conditions-online)
- [SQLAlchemy and SQLModel: When a Project Uses an ORM](https://www.ask-codey.com/lessons/fastapi-data-orms)

Source: https://www.ask-codey.com/lessons/fastapi-where-to-go-next
