The FastAPI SuperGuide: Create 3 Real-World FastAPI Apps

Explore the fundamentals of APIs, REST architecture, and CRUD operations, and learn how HTTP requests, headers, and status codes enable frontend–back end communication with JSON data.

Explore how fast API designs APIs in Python using open API and Json schema, leveraging type hints and Pydantic models to create validated, well-structured endpoints.

Type hints clarify variable types for editors and libraries, and in FastAPI they help restrict and construct your API endpoints using special types, while not changing the function's operation.

Explore pydantic models for fastapi by installing pydantic, defining a base model, using the typing module for lists and dicts, and composing inherited, nested models with optional fields.

Design a Pydantic social media post model with author, optional co-author, date, title, content, id, and likes; include a comments list with author, comment, and likes.

Implement a social media post model with Pydantic and pedantic base model, including optional co-author, date, id, likes, and nested comments.

Explore building a car information viewer with fast API fundamentals: search by id, create, edit, and delete cars via a json api, then render pages using Jinja2 and Bootstrap.

Create a FastAPI get /cars route using a mock database, with a Pydantic response model for a list of cars, and an optional query parameter to limit results.

Create a get car by id route in FastAPI using path parameters and a required integer id with Path validations, then return a car Pydantic model or raise a 404.

Update a car with a FastAPI put route that accepts optional fields for partial updates, validates the id, and returns a dictionary mapping a string to the updated car.

Delete a car by sending a delete request to a path with the car id, validate the id, delete it, and confirm with a 200 response.

Design the front end by setting up HTML templates with Jinja2 in FastAPI, organizing templates and static directories, and mounting static files to serve HTML responses.

Create and serve your first html page from a FastAPI API using jinja2 templates, passing the request and variables like title and text to the template response.

Split the home page into header and footer components with Jinja include, set default titles, and serve static files via url_for and a bootstrap CDN.

Design a responsive navigation bar using bootstrap, including logo, links, and a search form, built as a reusable navbar component for all pages with a dark theme.

Use Jinja templating and for loops to build a reusable car component, then render multiple cars with Bootstrap grid and properties like year, make, model, price, engine, and autonomous features.

Add a search feature by wiring a nav form to a fast API /search route, handle form data, and render a page showing the car or a not found message.

Implement an edit feature for the car viewer: add an edit button with a query id, load a pre-filled edit form, and post updates with a redirect.

Add a delete feature to a FastAPI app by wiring a red delete button to a /delete/{id} get route, and returning a redirect to the cars list.

Preview a social media feed app built with FastAPI, detailing authentication with password hashing, JWT tokens, cookies, environment variables, and secure login, register, and logout flows.

Install three libraries, including FastAPI login, bcrypt via pathlib, and python-dotenv; create main.py, mount static, set up templates, and a root route for testing with uvicorn.

Create Pydantic models for a user database, including a public user model and a database model with a hashed password, plus a notification model with author and description.

Integrate header, nav bar, and footer into a reusable base for a home page using Bootstrap, CSS, and Jinja templates, then render index.html via a template response.

Create a login page in a FastAPI app by building login.html with username and password fields. It posts to /login and prepares an invalid message placeholder for future login.

Implement password hashing to protect user passwords by converting them into irreversible hashes, then build hashing and verification functions using a crypt context with bcrypt in your app.

Implement user verification with fast api login, using a login manager, JWT tokens, and cookies, and get user from db via authentication logic.

Create a FastAPI login endpoint using OAuth2 password request form, authenticate users, issue an access token, set a cookie, and redirect unauthenticated requests to login.

Implement a logout mechanism by clearing the authentication cookie (token) and redirecting to the home page, using a /logout endpoint and a redirect response.

Create the front-end registration form by adding a /register HTML endpoint and rendering Register.html with username, email, name, and password fields. Style the form for centered display and bootstrap-ready layout.

Learn to build a back-end user registration in FastAPI by converting optional fields, validating unique usernames and emails, hashing passwords, storing new users, and redirecting to login with template feedback.

Convert home page into a front-end display of user information by rendering a template with the user object excluding the hashed password, using Bootstrap to show name, username, and friends.

Create and display a user notifications section by looping through user.notifications, rendering each notification’s author and description with clean styling, and show a 'no new notifications' message when empty.

Make bug fixes and refactor a FastAPI app by enabling the nav bar collapse, removing unused arguments, and streamlining login and registration flows for better security.

Create a real-time SQLite-backed to-do list app with OAuth2 web security, featuring user registration, login, task addition and completion, and logout, implemented in Python with SQLite integration.

Set up a FastAPI app by installing SQLAlchemy and Alembic, creating main, crud, db, schemas, and models, plus templates and static directories, and add a basic get route with uvicorn.

Create header, footer, and nav bar components in a FastAPI app, linking templates, static styles, and bootstrap to deliver a dynamic index.html with tasks, login, and register routes.

Enhance the home page with a centered welcome, a bootstrap container, and descriptive text prompting users to create an account or log in, setting up a future protected route.

Set up the database with SQLAlchemy by creating an engine, a declarative base, and a session maker, configure SQLite with check_same_thread set to false, and build the database context.

Create pydantic models for tasks and users using base schemas, with separate read and create classes, and enable orm mode to map database data for real-world apps.

Create database models in models.py using SQLAlchemy, inheriting from the base in db.py, defining user and task tables with columns, foreign keys, and relationships to back populate users and tasks.

Wire a FastAPI app to a database by importing db components, creating a get_db dependency with a with statement and yield, and using Depends for a simple tasks route.

Learn to manage database migrations with Alembic for SQLAlchemy projects, including setup, autogenerate revisions, and upgrades or downgrades based on the declarative base.

Develop a login page with a FastAPI login manager, cookie-based session, and CRUD utilities to fetch users by id or username using SQLAlchemy.

Learn to implement login in FastAPI by hashing passwords with bcrypt, building a user loader, authenticating with OAuth2, issuing access tokens, storing them in cookies, and securing routes.

Master FastAPI registration by building a registration page, implementing CRUD for user management, including get user by email and create user with UUID, and rendering register.html.

Implement a logout mechanism in FastAPI by clearing the authentication cookie with a response, redirecting to the home page, and validating the redirect to the login page after logout.

Build a tasks list in FastAPI by fetching tasks for a user, rendering them with a Jinja template, and styling with Bootstrap and Font Awesome icons.

Add tasks to a FastAPI app by converting the todo page into a post form to /tasks, linking tasks to users and showing validation errors.

Add a delete task operation and route to remove a task by id, commit changes, and redirect to /tasks. Ensure the user is authenticated before deletion.

Celebrate completing the course and building three real-world FastAPI apps; continue practicing with old projects, add validations and features, and explore next steps with the provided resources.