CAREER PATH · PYTHON BACKEND
We explain new ideas in plain language, practise repeatedly and build useful projects. Basic programming ideas are recommended; the path reviews the Python foundations needed for backend work.
from fastapi import FastAPI
app = FastAPI()Your first useful result is only a few careful steps away.EXPLORE BEFORE YOU START
Learn Python application structure, HTTP, FastAPI, SQL, authentication, testing and deployment through practical backend projects.
Basic programming ideas are recommended; the path reviews the Python foundations needed for backend work.
You can read this outline without signing in or completing onboarding. Start with the welcome screen above when you are ready to practise. Use a current browser; a keyboard and larger screen can make longer coding tasks easier, but the lesson interface also adapts to phones.
The in-page coding tasks use pattern checks to confirm required pieces. They do not replace installing the relevant framework, design application, Python environment or hosted service for full execution. Each section includes guided practice, projects and a ten-question exam.
Read an explanation, study the example, try the task and review feedback. Keep your own project files and test them in their intended environment. Completing an activity or a course certificate is not an accredited qualification or a guarantee of employment.
Expand a section to read its chapters and projects. This is the actual course curriculum, not a separate list of promised future topics.
Write readable Python with functions, collections, modules and useful errors.
Section outcome: Organise a command-line application across tested modules.
Model records with strings, numbers, lists, dictionaries and appropriate immutable values.
Create clear interfaces and distinguish expected results from exceptional failures.
Rebuild and vary the functions and exceptions example until every important piece feels familiar.
Split responsibilities and control public imports.
Keep project packages isolated and reproducible.
Rebuild and vary the virtual environments and dependencies example until every important piece feels familiar.
Separate input, calculation and reporting into modules.
Build a packaged Python application with tests and documented setup.
Understand requests, responses, resources and reliable API contracts.
Section outcome: Design a small REST-style API before choosing a framework.
Match read, create, update and delete intent to clear methods and responses.
Name resource collections and identifiers consistently.
Rebuild and vary the resources and urls example until every important piece feels familiar.
Define request and response fields, types and validation rules.
Keep failure and collection behaviour predictable as an API grows.
Rebuild and vary the errors, pagination and versioning example until every important piece feels familiar.
Design endpoints and examples for one resource.
Document resources, validation, errors and pagination before implementation.
Build typed endpoints with dependency injection and automatic documentation.
Section outcome: Implement a validated CRUD API with clear service boundaries.
Map HTTP requests to small endpoint functions.
Validate and document structured request and response data.
Rebuild and vary the pydantic models example until every important piece feels familiar.
Share database, authentication and other request-scoped requirements.
Keep business rules separate from HTTP and persistence details.
Rebuild and vary the service and repository layers example until every important piece feels familiar.
Build create and list endpoints with request models.
Implement routes, services and repositories for one complete resource.
Model related data, query it safely and preserve consistency.
Section outcome: Connect an API to a migrated relational database.
Represent entities and links with primary, foreign and uniqueness constraints.
Retrieve related records efficiently and readably.
Rebuild and vary the select and joins example until every important piece feels familiar.
Keep multi-step changes consistent when one step fails.
Evolve schema in reviewed steps and isolate persistence code.
Rebuild and vary the migrations and repositories example until every important piece feels familiar.
Model learners, courses and enrolments with constraints.
Add migrations, transactions and query tests to the service.
Verify identity, enforce permissions and protect secrets and input.
Section outcome: Add secure session or token authentication with tested authorisation rules.
Use established password hashing and never store plain passwords.
Choose an authentication mechanism based on clients and threat boundaries.
Rebuild and vary the sessions and tokens example until every important piece feels familiar.
Check whether the authenticated actor may perform the requested action.
Protect credentials and constrain untrusted input and request rates.
Rebuild and vary the secrets, validation and abuse controls example until every important piece feels familiar.
Identify assets, actors, entry points and mitigations for one API.
Implement login and object-level authorisation with security tests.
Test rules, database behaviour and HTTP contracts in isolation and together.
Section outcome: Create a dependable automated backend test suite.
Protect business rules without involving the network or real database.
Send requests through the application and verify contracts.
Rebuild and vary the api integration tests example until every important piece feels familiar.
Give tests known data without leaking state between them.
Record useful context without exposing secrets.
Rebuild and vary the logging and diagnosis example until every important piece feels familiar.
Reproduce one backend bug and protect the fix.
Cover services, database repositories, HTTP contracts and permissions.
Package, configure, observe and recover a production service.
Section outcome: Deploy a database-backed API with health checks and logs.
Run the service reproducibly with explicit dependencies and startup commands.
Separate environment-specific values from committed source.
Rebuild and vary the configuration and secrets example until every important piece feels familiar.
Expose readiness and capture enough context to diagnose failures.
Protect persistent data and rehearse schema changes and restoration.
Rebuild and vary the backups and migrations example until every important piece feels familiar.
Document configuration, health and recovery for a sample API.
Deploy staging, migrate data, test health and practise rollback.
Combine contracts, persistence, security, tests and operations into one service.
Section outcome: Publish a documented API another developer can safely use.
Turn user needs into resources, rules and permission boundaries.
Provide accurate examples, errors and setup guidance.
Rebuild and vary the openapi and developer experience example until every important piece feels familiar.
Measure critical queries and constrain expensive or repeated requests.
Explain architecture, trade-offs, tests and operational evidence.
Rebuild and vary the technical case study example until every important piece feels familiar.
Document one important technology decision and its trade-offs.
Design, build, secure, test, deploy and present a complete backend service.
Guest progress is saved in this browser on this device. Clearing site data or switching browsers can remove access to that local progress. An optional account can synchronize supported course progress; it is not required to access the lessons. Download or back up project work separately.
Certificates recognize completion of the course activities on this site. They are not university credit, professional accreditation or proof that every program you write is correct.