We may earn an affiliate commission when you visit our partners.
Course image
Sourabh Sinha

This course is a guide to learn FastAPI. The FastAPI documentation is one of the best documentation. This course is for students who love videos as a medium to learn. We will be learning FastAPI with best practices. The Test-Driven Development goat ? will guide our development process. TDD is the way to think of the code before we actually write a piece of code. In this course we will be learning the following core concepts:

Read more

This course is a guide to learn FastAPI. The FastAPI documentation is one of the best documentation. This course is for students who love videos as a medium to learn. We will be learning FastAPI with best practices. The Test-Driven Development goat ? will guide our development process. TDD is the way to think of the code before we actually write a piece of code. In this course we will be learning the following core concepts:

  • Creating APIs : We will implement the below endpoints:

    • Create

    • Retrieve

    • Update

    • Delete

    • List Blogs

  • User Authentication with basic security

    • Password will be hashed to provide additional security

    • We will use JSON Web Tokens to authenticate

    • Tokens won't be stored in LocalStorage or Cookies

    • Token will be stored in HttpOnly cookie

  • Version Control System

    • We will use GIT as our Version Control

    • Github will be used to host our code

  • Creating web apps

    • We will use Jinja Templating Language

    • We will be working with several forms

  • Unit Testing

    • Tests will be written in Pytest

    • After each testing cycle, the Test database will be cleaned

    • Test Coverage

    • How not to write unit tests?

  • Permissions: A user who has not created the blog, won't be able to delete it.

  • We will work with Postgres and monitor it using PgAdmin.

Fastapi provides us with built-in OpenAPI docs, we will use the documentation to the fullest. The docs help backend and frontend developers collaborate easily with each other.

Enroll now

What's inside

Learning objective

Learn to develop an api as well as webapp using fastapi with best practices and unit testing.

Syllabus

Introduction
Project Demonstration

Understanding the course structure and setting up our system.

Github Repo. and exact version of Packages used
Read more

Traffic lights

Read about what's good
what should give you pause
and possible dealbreakers
Uses FastAPI, which allows developers to build APIs quickly and efficiently, making it suitable for rapid application development and deployment
Employs Test-Driven Development, which is a robust approach to software development that emphasizes writing tests before writing the actual code
Covers user authentication with JSON Web Tokens, which are stored in HttpOnly cookies, enhancing security and protecting against common web vulnerabilities
Integrates Git for version control and Github for hosting, which are essential tools for collaborative software development and project management
Utilizes Jinja templating language for creating web applications, which is a flexible and powerful tool for generating dynamic HTML content
Requires familiarity with Python type hints, iterators, generators, and asynchronous programming, which may pose a challenge for beginners without prior experience

Save this course

Create your own learning path. Save this course to your list so you can find it easily later.
Save

Reviews summary

Comprehensive fastapi full stack development

According to learners, this course provides a solid foundation in building full-stack web applications using the FastAPI framework. Many students appreciate the emphasis on best practices, including Test-Driven Development (TDD) and writing comprehensive unit tests using Pytest. The practical, hands-on projects are frequently highlighted as a major strength, offering valuable experience in applying concepts like user authentication and integrating with databases such as Postgres. While generally seen as a valuable resource for developers aiming to learn FastAPI, some reviewers note that keeping up with the rapid evolution of the library and its dependencies can sometimes require supplementary research to address minor version differences encountered during setup.
May require prior Python knowledge.
"While excellent, the pace can be fast at times if you're not already comfortable with Python async or SQLAlchemy basics."
"I needed to brush up on some Python fundamentals and async concepts before diving into the course content effectively."
"Felt the course was best suited for those with some prior web dev or Python backend experience, not absolute beginners."
Detailed coverage of core FastAPI features.
"The course does an excellent job covering the core concepts of FastAPI, from endpoints to dependencies and data models."
"Really helped solidify my understanding of the asynchronous nature and core principles behind building APIs with FastAPI."
"Provides a clear introduction to FastAPI's features, including Pydantic models and dependency injection."
Covers TDD and unit testing with Pytest.
"I appreciated the emphasis on TDD and writing proper unit tests using Pytest, it's a valuable skill often overlooked in other courses."
"The section on Pytest was clear and helped me integrate testing into my own workflow effectively."
"Learning how to structure the project with best practices and testing was a major plus for improving code quality."
Learn by building a full-stack application.
"The hands-on coding and projects are the strongest part of the course for me, applying the concepts immediately was key."
"Building the project step-by-step really helped solidify my understanding of how the different parts connect in a real application."
"I found the practical exercises and project development highly beneficial for gaining real-world experience."
FastAPI evolves, minor updates needed.
"FastAPI moves quickly, and some minor package version differences caused initial setup headaches compared to the course videos."
"Could use more in-depth coverage on the absolute latest FastAPI features or recent changes to libraries like SQLAlchemy."
"Occasionally found small discrepancies due to library updates since the course was published, requiring some troubleshooting."

Activities

Be better prepared before your course. Deepen your understanding during and after it. Supplement your coursework and achieve mastery of the topics covered in FastAPI Full Stack Web Development with these activities:
Review Python Type Hints
Reviewing Python's type hinting system will make understanding FastAPI's data validation and dependency injection much easier.
Browse courses on Python Basics
Show steps
  • Read the official Python documentation on type hints.
  • Practice writing functions with type hints.
  • Experiment with different type hint annotations.
Read 'Python Crash Course'
Reading a Python fundamentals book will help solidify your understanding of the language before learning FastAPI.
Show steps
  • Read the first half of the book covering basic Python concepts.
  • Complete the exercises at the end of each chapter.
  • Focus on chapters related to functions and data structures.
Practice SQL Queries
Practicing SQL queries will help you understand how to interact with the database in your FastAPI application.
Show steps
  • Set up a local PostgreSQL database.
  • Create tables and insert sample data.
  • Write SQL queries to retrieve, update, and delete data.
Four other activities
Expand to see all activities and additional details
Show all seven activities
Build a Simple CRUD API
Building a simple CRUD API will allow you to apply the concepts learned in the course and solidify your understanding of FastAPI.
Show steps
  • Define the API endpoints (Create, Read, Update, Delete).
  • Implement the API logic using FastAPI.
  • Test the API endpoints using a tool like Postman.
Read 'Test-Driven Development with Python'
Reading a book on TDD will help you write better unit tests for your FastAPI applications.
Show steps
  • Read the chapters on TDD principles and practices.
  • Follow the examples and implement the code yourself.
  • Adapt the TDD techniques to your FastAPI projects.
Write a Blog Post on FastAPI Authentication
Writing a blog post will help you consolidate your knowledge of FastAPI authentication and share it with others.
Show steps
  • Research different authentication methods in FastAPI.
  • Choose a specific method (e.g., JWT) and explain it in detail.
  • Provide code examples and explanations.
  • Publish the blog post on a platform like Medium.
Contribute to a FastAPI Open Source Project
Contributing to open source will give you valuable experience working with a real-world FastAPI project and collaborating with other developers.
Show steps
  • Find a FastAPI open source project on GitHub.
  • Identify a bug or feature to work on.
  • Submit a pull request with your changes.

Career center

Learners who complete FastAPI Full Stack Web Development will develop knowledge and skills that may be useful to these careers:
Backend Developer
A Backend Developer builds and maintains the server-side logic and databases that power applications. This course helps build a foundation for designing, developing, and testing robust APIs using FastAPI, a modern, high-performance web framework. The focus on creating create, retrieve, update, and delete endpoints, as well as user authentication using JSON Web Tokens, directly translates to practical backend development skills. Furthermore, the course content on database interaction with Postgres using SQLAlchemy and Alembic for database migrations helps in managing data efficiently. A prospective Backend Developer should take this course to learn and apply best practices, including Test Driven Development, and gain hands-on experience.
API Developer
An API Developer specializes in designing, building, and managing APIs that allow different software systems to communicate with each other. This course is centered around learning FastAPI, a framework specifically designed for building APIs, providing a solid understanding of API development principles and practices. The course covers crucial aspects like creating create, retrieve, update, and delete endpoints, implementing user authentication, and working with databases, all essential for an API Developer. The material on using OpenAPI documentation facilitates easy collaboration between backend and frontend developers. This course is recommended for individuals aiming to become proficient API Developers, emphasizing hands-on experience and best practices.
Full Stack Engineer
A Full Stack Engineer works on both the front-end and back-end of applications. This course is a good fit by building a foundation in developing APIs with FastAPI and creating web applications using Jinja templating. The user authentication with JSON web tokens and form handling skills taught in this course are valuable for building secure and interactive web applications. The emphasis on version control with Git and GitHub is essential for collaborative development. Aspiring Full Stack Engineers should choose this course to gain practical experience in building full-fledged web applications with a focus on both the server-side and client-side aspects.
Web Application Developer
A Web Application Developer focuses on creating and maintaining web applications, which often involves both front-end and back-end development. This course builds a foundation for developing web applications using FastAPI and Jinja templating. The course provides practical experience in handling forms, serving static files, and creating interactive web pages. Learning how to secure applications with user authentication and authorization adds another layer of value. Potential Web Application Developers should consider this course to learn FastAPI and related technologies, especially given the emphasis on building full applications and not just APIs.
Software Engineer
A Software Engineer designs, develops, and tests software systems. This course may be useful by providing hands-on experience with FastAPI, a modern web framework, along with test-driven development (TDD). The coverage of version control with Git and GitHub, as well as unit testing, are valuable components of software development. A Software Engineer may benefit from this course, particularly if they are interested in web development and API design.
DevOps Engineer
A DevOps Engineer focuses on automating and streamlining the software development lifecycle. This course may be useful by teaching how to use Git and GitHub for version control, and how to set up Alembic for database migrations. Understanding how to configure and manage databases, along with deploying applications, can be valuable for a DevOps Engineer. The course emphasis on best practices and test-driven development may be found useful for improving software quality and reliability. Those aspiring to become DevOps Engineers may consider this course to enhance their skills in web development and deployment.
QA Engineer
A QA Engineer is responsible for ensuring the quality of software through testing and validation. This course may be useful by providing an introduction to unit testing with Pytest, including writing tests, configuring Pytest, and understanding test coverage. The focus on Test Driven Development may be helpful for understanding how to write effective tests. Future QA Engineers who want to gain hands-on experience with testing web applications may take this course to build their skills in quality assurance.
Data Engineer
A Data Engineer designs, builds, and maintains data pipelines and infrastructure. This course may be useful by providing an introduction to working with Postgres databases and setting up Alembic for database migrations. The course may help with understanding how to connect to databases, create tables, and manage data. Aspiring Data Engineers who want to gain experience with database management and API development may find this course to be a helpful starting point.
Database Administrator
A Database Administrator manages and maintains databases, ensuring their security, performance, and availability. This course is a potential fit by covering how to work with Postgres databases, configure environment variables for database secrets, and set up Alembic for database migrations. Learning how to create tables, implement database schemas, and connect to databases provides practical skills for database management. Those wishing to become Database Administrators may take this course to gain hands-on experience with database technologies and practices.
Security Engineer
A Security Engineer protects computer systems and networks from threats. This course may be useful by covering user authentication with JSON Web Tokens and password hashing. Learning how to build secure API endpoints and implement authorization mechanisms for limiting access helps in understanding how to protect web applications. Those aiming to become Security Engineers may take this course to potentially enhance their knowledge of web application security.
Technical Lead
A Technical Lead manages a team of developers and oversees technical projects. This course may be useful by providing hands-on experience with FastAPI, test-driven development, and version control with Git and GitHub, all important for guiding a team. The emphasis on understanding project structure, best practices, and unit testing may be useful for a technical lead. Technical Leads who want to ensure their skills are current with modern web development can take this course.
Solution Architect
A Solution Architect designs and implements IT solutions to meet business needs. This course may be useful by teaching how to build APIs with FastAPI, integrate databases, and implement user authentication, all important components of software solutions. Understanding how to leverage OpenAPI documentation for collaboration may be useful for designing interoperable systems. If you are an aspiring Solution Architect, this course may help in gaining practical skills in web development and system design.
IT Consultant
An IT Consultant advises organizations on how to use information technology to meet their business objectives. This course may be useful by providing practical experience with FastAPI, web application development, and database integration. Understanding how to build APIs, implement user authentication, and manage data can be valuable in recommending IT solutions. Aspiring IT Consultants looking to build their technical skills and expand their knowledge of web application development may find this course useful.
Project Manager
A Project Manager plans, executes, and closes projects, ensuring they are completed on time and within budget. This course may be useful by providing an understanding of web development processes, including API design, version control, and testing. Awareness of the technologies and practices used in software development can help project managers communicate effectively with development teams and manage projects more efficiently. If one's goal is to become a Project Manager, they may use this course to gain insights into modern web development technologies and methodologies.
UX Designer
A UX Designer focuses on enhancing user satisfaction by improving the usability, accessibility, and desirability of a product. This course may be useful by providing an understanding of how web applications are built and how data is managed on the back end. While the course focuses on backend and API development, a UX Designer may find the material about building a webapp using FastAPI, Jinja, and forms is valuable for understanding the technical constraints and possibilities when designing user interfaces. Gaining this understanding from the course may help UX designers create more practical and effective designs.

Reading list

We've selected two books that we think will supplement your learning. Use these to develop background knowledge, enrich your coursework, and gain a deeper understanding of the topics covered in FastAPI Full Stack Web Development.
Provides a comprehensive guide to test-driven development (TDD) in Python, using Django as a practical example. While the course uses Pytest, the principles of TDD remain the same. Understanding TDD will help you write more robust and maintainable FastAPI applications. This book is valuable as additional reading to reinforce the TDD concepts introduced in the course.
Provides a solid foundation in Python programming, covering essential concepts like data structures, functions, and object-oriented programming. It's particularly helpful for beginners or those looking to refresh their Python skills before diving into FastAPI. The project-based approach allows you to apply your knowledge in practical scenarios. While not specific to web development, it builds a strong base for understanding FastAPI concepts.

Share

Help others find this course page by sharing it with your friends and followers:

Similar courses

Similar courses are unavailable at this time. Please try again later.
Our mission

OpenCourser helps millions of learners each year. People visit us to learn workspace skills, ace their exams, and nurture their curiosity.

Our extensive catalog contains over 50,000 courses and twice as many books. Browse by search, by topic, or even by career interests. We'll match you to the right resources quickly.

Find this site helpful? Tell a friend about us.

Affiliate disclosure

We're supported by our community of learners. When you purchase or subscribe to courses and programs or purchase books, we may earn a commission from our partners.

Your purchases help us maintain our catalog and keep our servers humming without ads.

Thank you for supporting OpenCourser.

© 2016 - 2025 OpenCourser