What is the FastAPI Development Course course?
Learn FastAPI through a ten-part curriculum that starts with your first endpoint and develops a Student Management REST API. Work through HTTP methods, input validation, a clear project structure and PostgreSQL persistence before adding authentication and supporting tools.
What will you build?
A practice API with validated student records, persistent CRUD operations and authenticated routes. Separate exercises introduce async database access, request middleware, expiring cache entries, queued tasks, automated tests and a local container setup.
Who is this course for?
Python learners moving into backend development and developers who want a structured introduction to FastAPI. Basic Python functions, collections, classes and exception handling are useful prerequisites; previous FastAPI experience is not required.
How is the curriculum organised?
Ten modules follow the learning sequence from API foundations to supporting development tools. Each module includes topic lessons and a practical outcome. Later integrations are introductions rather than a claim of advanced production expertise.
What should you know before joining?
Be comfortable writing and running small Python programs. For a broader foundation, explore the Python, Backend & Generative AI Program. Discuss the suitable starting point and current class arrangements through the enquiry form.
Course enquiry
Ask about prerequisites, the available learning format, batch schedule and course details. Duration, fees and class arrangements are confirmed during counselling.
Who can join?
Python learners and developers beginning API development with FastAPI.
What do you need before starting?
Basic Python syntax, functions, lists and dictionaries, classes and exception handling. Ability to run Python and install packages in a virtual environment.
YOUR LEARNING PATH
What will you learn in FastAPI Development Course?
The FastAPI Development Course course has 10 modules: 01. FastAPI foundations and your first API, 02. HTTP methods and resource operations, 03. Path parameters, query parameters and request bodies, 04. Pydantic models and response validation, 05. Build a complete CRUD API, 06. Project structure, APIRouter and dependency injection and 4 more. Open a module below to see its lessons and what you will be able to do after it.
01. FastAPI foundations and your first API
5 lessons
02. HTTP methods and resource operations
5 lessons
03. Path parameters, query parameters and request bodies
5 lessons
04. Pydantic models and response validation
5 lessons
05. Build a complete CRUD API
5 lessons
06. Project structure, APIRouter and dependency injection
5 lessons
07. PostgreSQL and SQLAlchemy persistence
6 lessons
08. JWT authentication and API security
6 lessons
09. Async programming, middleware and background tasks
6 lessons
10. Redis, Celery, testing and Docker
8 lessons
0101. FastAPI foundations and your first API5 lessons
Understand how clients, API endpoints and JSON responses fit together, then create and inspect a small FastAPI application.
Explain the request-response flow of a small web application. Prepare an isolated FastAPI development environment. Write and run a simple GET endpoint. Use interactive documentation to explore an API. Create and explain a small multi-route practice API.
What an API does
Trace a request from a frontend to a Python endpoint and back as a JSON response. Distinguish the API layer from the database.
Explain the request-response flow of a small web application.
Project setup and virtual environments
Create a project folder, isolate its Python dependencies and install FastAPI with its standard development tools.
Prepare an isolated FastAPI development environment.
Create an application and route
Create the FastAPI application object, add GET routes and return structured Python data as JSON.
Write and run a simple GET endpoint.
Run and inspect the development server
Start the development application and use the generated Swagger UI documentation to send requests and inspect responses.
Use interactive documentation to explore an API.
Practice: a small course-information API
Build welcome, about and course-list endpoints. Check the response shape and explain the route decorators and handler functions.
Create and explain a small multi-route practice API.
0202. HTTP methods and resource operations5 lessons
Use the five core HTTP methods to read, create, replace, partially update and remove resources in a temporary in-memory application.
Implement collection and detail reads. Implement resource creation with appropriate response semantics. Explain and implement full resource replacement. Handle partial updates without overwriting omitted fields. Exercise all five methods and identify temporary-storage limits.
GET collections and individual resources
Retrieve a list and a record by ID; return a clear not-found response when the record is absent.
Implement collection and detail reads.
POST and resource creation
Accept a modelled request body, add a resource and distinguish successful creation from conflicting identifiers.
Implement resource creation with appropriate response semantics.
PUT and full replacement
Replace a resource representation and check consistency between the URL identifier and submitted data.
Explain and implement full resource replacement.
PATCH and partial changes
Apply only fields included by the client and contrast a partial change with replacement.
Handle partial updates without overwriting omitted fields.
DELETE and method-by-method practice
Remove a resource and test the complete request sequence through interactive documentation. Explain why in-memory records disappear on restart.
Exercise all five methods and identify temporary-storage limits.
0303. Path parameters, query parameters and request bodies5 lessons
Choose where input belongs in an HTTP request and combine typed parameters with structured JSON bodies.
Define and consume typed path parameters. Use query parameters to refine a collection request. Parse a structured JSON request body. Validate multiple input sources in one operation. Design a consistent request contract for a small API.
Typed path parameters
Use an integer resource identifier in a URL and observe how invalid path values are handled.
Define and consume typed path parameters.
Query parameters for filters and limits
Accept optional filters and pagination-style limits without confusing them with resource identity.
Use query parameters to refine a collection request.
JSON bodies with Pydantic
Define a request-body model and inspect how submitted JSON becomes typed application data.
Parse a structured JSON request body.
Combine input sources and validation
Combine a path ID, optional query flags and a request body. Apply numeric and string constraints using Path and Query.
Validate multiple input sources in one operation.
Practice: course-management requests
Implement resource lookup, filtered listing, creation and update requests with clearly separated inputs.
Design a consistent request contract for a small API.
0404. Pydantic models and response validation5 lessons
Define the data an API accepts and returns, including field constraints, nested structures and safe output models.
Model required, optional and nullable inputs deliberately. Reject invalid data with explicit model constraints. Explain validation behaviour for nested request data. Control the documented and returned response shape. Build and check a validated registration API.
Required fields, defaults and optional values
Distinguish a required value, an omitted field with a default and an explicitly nullable value.
Model required, optional and nullable inputs deliberately.
Field constraints and email validation
Apply length and numeric bounds and use email validation with its required supporting dependency.
Reject invalid data with explicit model constraints.
Type conversion and nested models
Examine supported type conversion and represent related structured values with nested models.
Explain validation behaviour for nested request data.
Response models and data boundaries
Separate input and output schemas, use response_model and keep sensitive or internal fields out of public responses.
Control the documented and returned response shape.
Practice: student registration
Create a registration request with field validation and a separate response model; exercise valid and invalid requests.
Build and check a validated registration API.
0505. Build a complete CRUD API5 lessons
Bring methods, schemas, validation and errors together in a Student Management REST API before introducing persistent storage.
Separate resource input and output responsibilities. Build the create and read parts of a CRUD workflow. Preserve intended values across PUT and PATCH requests. Extend CRUD with useful collection operations. Demonstrate and explain an end-to-end CRUD application.
Define create, update and public schemas
Use distinct models for creating a record, changing selected fields and returning public data.
Separate resource input and output responsibilities.
Create and retrieve student records
Implement creation, list and detail operations with stable identifiers and clear not-found responses.
Build the create and read parts of a CRUD workflow.
Full and partial updates
Implement replacement and partial changes consistently, including omitted fields and invalid identifiers.
Preserve intended values across PUT and PATCH requests.
Delete, search and filter
Remove records and add basic search or filter inputs while keeping collection behaviour understandable.
Extend CRUD with useful collection operations.
Practice: validate the complete workflow
Exercise creation, retrieval, updates, filtering, deletion and invalid requests. Explain which concerns change when moving to a real database.
Demonstrate and explain an end-to-end CRUD application.
0606. Project structure, APIRouter and dependency injection5 lessons
Organise an expanding application into schemas, routers, services and reusable dependencies.
Navigate and explain a multi-file FastAPI project. Compose an application from related route groups. Keep business operations separate from transport concerns. Inject shared behaviour into route handlers. Reuse dependencies across a route group.
Separate responsibilities across files
Organise application setup, schemas, routing and business logic so each part has a clear role.
Navigate and explain a multi-file FastAPI project.
Use APIRouter
Group related endpoints, configure route prefixes and tags, and connect routers to the main application.
Compose an application from related route groups.
Introduce a service layer
Move reusable record operations away from HTTP handlers while preserving response and validation behaviour.
Keep business operations separate from transport concerns.
Reusable dependencies with Depends
Create dependencies for shared values and checks, including reusable skip-and-limit parameters.
Inject shared behaviour into route handlers.
Router-wide dependencies and refactoring practice
Apply shared checks to a router and refactor the student API without changing its public contract.
Reuse dependencies across a route group.
0707. PostgreSQL and SQLAlchemy persistence6 lessons
Replace temporary records with a relational database and understand models, sessions, relationships and persistent CRUD operations.
Explain persistent relational storage and connection configuration. Distinguish ORM models from API schemas. Manage database work within an appropriate session lifecycle. Implement persistent CRUD operations. Explain and use a basic relationship between tables. Demonstrate a database-backed version of the practice API.
Relational storage and PostgreSQL connections
Understand tables, keys and persistent data; configure database connection settings outside application source.
Explain persistent relational storage and connection configuration.
SQLAlchemy models and schema separation
Represent database tables with ORM models while keeping database entities distinct from Pydantic request and response schemas.
Distinguish ORM models from API schemas.
Sessions and request-scoped access
Create and close database sessions through dependencies, and understand commit and rollback boundaries.
Manage database work within an appropriate session lifecycle.
Persist the CRUD workflow
Create, query, change and remove records through SQLAlchemy instead of an application-level list.
Implement persistent CRUD operations.
Database relationships
Introduce related records through foreign keys and ORM relationships, and consider how related information is exposed in responses.
Explain and use a basic relationship between tables.
Practice: a persistent student API
Move the existing application to PostgreSQL, check data across restarts and handle missing or conflicting records.
Demonstrate a database-backed version of the practice API.
0808. JWT authentication and API security6 lessons
Add registration, password hashing, login and authenticated access while separating identity checks from permission decisions.
Explain the purpose and limitations of bearer tokens. Keep credentials out of public user responses. Implement password handling appropriate to a learning application. Implement a basic credential-to-token login flow. Protect an endpoint and handle invalid or expired tokens. Demonstrate a bounded authenticated API workflow.
Authentication, authorization and JWT
Distinguish proving identity from deciding access. Explain token claims, expiry and why signed JWT contents are not inherently confidential.
Explain the purpose and limitations of bearer tokens.
User models and safe schemas
Represent users in the database and separate registration fields from public output and stored password hashes.
Keep credentials out of public user responses.
Password hashing and registration
Hash and verify passwords with maintained tooling and build registration without storing plaintext passwords.
Implement password handling appropriate to a learning application.
Login and access-token creation
Accept login credentials, verify them and issue an expiring token using protected signing configuration.
Implement a basic credential-to-token login flow.
Current-user dependencies and protected routes
Validate allowed token algorithms and expiry, resolve the current user and apply access checks through dependencies.
Protect an endpoint and handle invalid or expired tokens.
Practice: authenticated student operations
Test registration, login, authorized requests and failed access through Swagger UI. Review secret handling and which security questions need application-specific design.
Demonstrate a bounded authenticated API workflow.
0909. Async programming, middleware and background tasks6 lessons
Understand non-blocking I/O, async database access and request middleware, then distinguish in-process tasks from independent workers.
Explain when asynchronous execution helps an API. Avoid blocking an event loop with synchronous I/O. Configure the main components of async database access. Use async sessions without sharing mutable session state across tasks. Implement and explain simple request middleware. Choose between request handling, in-process tasks and a task queue.
Synchronous and asynchronous Python
Use async, await and coroutine examples to understand waiting for I/O rather than assuming async makes every task faster.
Explain when asynchronous execution helps an API.
Blocking calls and endpoint selection
Compare time.sleep with asyncio.sleep and choose def or async def based on the libraries and work involved.
Avoid blocking an event loop with synchronous I/O.
Async PostgreSQL connections
Introduce an async database driver, engine and session factory using SQLAlchemy.
Configure the main components of async database access.
AsyncSession CRUD and lifecycle
Await database work and manage an independent session lifecycle for each request or concurrent task.
Use async sessions without sharing mutable session state across tasks.
Request middleware
Add timing middleware around a request and understand the request-response sequence and response headers.
Implement and explain simple request middleware.
BackgroundTasks and their limits
Run a small post-response task and contrast in-process work with a separate Celery worker for heavier or distributed tasks.
Choose between request handling, in-process tasks and a task queue.
1010. Redis, Celery, testing and Docker8 lessons
Introduce four supporting tools through small exercises: expiring cache entries, independent task workers, automated API checks and container packaging.
Use a cache entry with an explicit expiry. Explain cache freshness and fallback concerns. Explain the API-broker-worker relationship. Submit a task without doing its long-running work inside the request. Create and run basic automated endpoint checks. Explain the components of a FastAPI container image. Run a containerized practice application and explain a Compose setup. Present and explain the components and limitations of the practice project.
Redis and expiring cache entries
Introduce Redis as an in-memory data store, connect a practice application and cache a response with a time-to-live.
Use a cache entry with an explicit expiry.
Cache behaviour and correctness
Compare cache hits and misses and consider stale values, invalidation and what should happen when the cache is unavailable.
Explain cache freshness and fallback concerns.
Celery application and worker architecture
Configure a small task, a broker and a worker, then distinguish task execution from the API process.
Explain the API-broker-worker relationship.
Trigger and inspect a background task
Queue a task from an endpoint and follow its task identifier. Use a supported Linux environment or container for worker practice.
Submit a task without doing its long-running work inside the request.
Pytest and TestClient
Write API tests for response status and JSON values, run the test suite and understand how failures guide a correction.
Create and run basic automated endpoint checks.
Dockerfile and container images
Describe a small application image, install its dependencies and configure the command that starts the API.
Explain the components of a FastAPI container image.
Build, run and use Docker Compose
Build and run a local container with explicit ports, then introduce Compose for related development services and configuration.
Run a containerized practice application and explain a Compose setup.
Integration practice and project review
Check the Student Management API, authentication, database access, one cache example, one worker task, tests and container setup. Keep secrets out of source and distinguish local container practice from a hardened production deployment.
Present and explain the components and limitations of the practice project.
What will you explore in FastAPI Development Course?
FastAPI Development Course covers build a Python REST API, explain a complete practice project, API design and input validation, fastAPI and supporting backend tools, python learners entering backend development, ten connected modules and 2 more. Each part is explained below, so you know what is included before you join.
Build a Python REST API
Explain a complete practice project
API design and input validation
FastAPI and supporting backend tools
Python learners entering backend development
Ten connected modules
A foundation-first progression through API development and supporting tools.
A project that develops with the curriculum
Return to a Student Management API while adding persistence, authentication and tests.
Practice and explain
Use coding exercises, request checks and clear learning outcomes throughout the course.
CLEAR ANSWERS
What do people ask about FastAPI Development Course?
Short answers to the questions people ask most often about FastAPI Development Course. Open a question to read the answer, or contact Mayexa Technologies if yours is not covered here.
Do I need to know Python before learning FastAPI?
Basic Python is recommended, including functions, collections, classes and exception handling. Previous FastAPI experience is not required.
What does the FastAPI course cover?
The ten modules cover API foundations, HTTP methods, request parameters, Pydantic, CRUD, project structure, dependency injection, PostgreSQL, SQLAlchemy, JWT authentication, async programming, middleware, background tasks, Redis, Celery, testing and Docker.
Which project will I practise?
The curriculum develops a Student Management REST API. Additional small exercises introduce caching, independent workers, automated tests and container packaging.
Does the course include database and authentication topics?
Yes. Modules introduce PostgreSQL with SQLAlchemy, request-scoped sessions, basic relationships, password hashing, token-based login and protected routes.
Is Docker practice the same as deploying a production system?
No. Local container exercises explain packaging and running an application. A production deployment also needs application-specific security, networking, monitoring, backup and operational design.
How can I confirm duration, fees and class arrangements?
Use the course enquiry form to discuss your starting level and current arrangements. Duration, fees, batch schedule and learning format are confirmed during counselling.
Book a counselling session
Share your starting level and learning goals to arrange a counselling session for FastAPI Development Course. We will discuss the right learning path and batch arrangements with you.