Skip to content
Development BE—01

Your own backend

A course about the server side: what happens after the frontend sends a request. We build a real shop API on FastAPI — catalogue, users, cart, orders — and at the end we connect the React shop from «React in practice» to it instead of a toy json-server.

10 modules31 lessons
24 hoursof video and practice
Python basics neededrequirements
Foreveraccess and updates
Format
€72 one-off payment
Place the order Open the programme
Payment by card or through PayPal
Access opens immediately after payment
14-day refund, if you have not started watching
Outcome

What you will be able to do

Explain what happens between the browser's request and the server's response
Build an API on FastAPI: routes, parameters, status codes, documentation
Describe data schemas and validate input before it reaches the database
Store data in a database, write queries and run migrations
Build catalogue CRUD with search, filters and pagination
Set up users: passwords, tokens and protected endpoints
Calculate the cart and orders on the server instead of trusting numbers from the client
Deploy the API to a server with HTTPS and connect a finished frontend to it
Programme

10 modules, one project

Press a module to open its lessons

01 What a backend is3 lessons · 2 h 12 minOpen

We start with the whole picture: who sends what to whom, what a request consists of and why an API is a contract.

Request and response: methods, headers, status codes
JSON as the contract between the frontend and the server
Practice: reading someone else's API from its documentation
02 Your first API on FastAPI3 lessons · 2 h 20 min

We start the server, write the first routes and get documentation we did not have to write by hand.

Installation, the first route and auto-reload
Path parameters, query parameters and the request body
Documentation out of the box: Swagger and checking by hand
03 Data schemas and validation3 lessons · 2 h 16 min

The contract in code: what we accept, what we return and what happens to rubbish on the way in.

Pydantic models: types, required fields, default values
Your own validation rules and clear validation errors
Different schemas in and out: what we do not expose
04 The database3 lessons · 2 h 30 min

The data stops living in a list in memory: tables, relations, queries and migrations without editing the schema by hand.

Tables and relations: products, categories, users
Queries through the ORM: selection, filters, sorting
Migrations: changing the schema without losing data
05 Catalogue CRUD3 lessons · 2 h 28 min

The full set of operations on products, plus the things a catalogue cannot live without: search, filters and pages.

Create, read, update, delete a product
Search, filters and sorting on the server side
Pagination and what to return in a list
06 Users and signing in3 lessons · 2 h 32 min

Registration and sign-in done properly: passwords are not stored, tokens are verified, other people's data is not handed out.

Registration and storing a password: hash and salt
Tokens: issuing, lifetime, refreshing
Protected routes and access rights
07 Cart and orders3 lessons · 2 h 26 min

The logic you cannot trust the client with: price, availability, order statuses and an honest payment stub.

The cart on the server: why the backend calculates the total
An order and its statuses: from creation to cancellation
Payment: a stub you would not be ashamed to swap for the real thing
08 Files and product images3 lessons · 2 h 08 min

Uploading, storing and serving files — with the checks that keep the wrong things off your server.

Receiving a file: size, type, safe filename
Storing and serving images, thumbnails for a list
Practice: a product card with photographs
09 Errors, logs and API tests3 lessons · 2 h 16 min

We make a service that breaks legibly: one error format, logs that earn their place and tests for the key scenarios.

A single error format and your own handlers
Logs: what to write so you can work it out later
Endpoint tests: an order goes through end to end
10 Deployment and connecting the frontend4 lessons · 2 h 52 min

The final module: server, domain, HTTPS — and the React shop that starts running on your API.

Server, environment and running the service as a daemon
Domain, HTTPS and the reverse proxy
CORS and connecting the React shop instead of json-server
Final project: an order goes from the button to the database
Materials

What you get

31 lessons with transcripts

Videos with timecodes and a written version: the code and commands from a lesson copy across whole, together with the terminal output.

A collection of API requests

A ready set of requests to every endpoint in the course: you can check your server without assembling each request by hand.

The shop data schema

Tables, relations and fields with notes on why the entities are split exactly this way — together with ready migrations.

The frontend from «React in practice»

The same shop you built in FE—02, with a switch between json-server and your API — so connecting it takes no rewriting.

Alina Mihai
Course author

Alina Mihai

Teaches the «Python and backend» direction at Forma. The full list of their courses is on their page.

All courses by this author

The whole first module is open

Watch the lessons of the first module and the first task. If the format does not suit you, you have lost nothing.