MongoDB with Async Python is a 111-lesson 7 hours 19 minutes self-paced course by Talk Python Training. Most MongoDB tutorials stop at the shell and a few CRUD commands.
Course facts
Lessons
111
Duration
7 hours 19 minutes
Level
All levels
Language
English
Updated
2026-09-11
Instructor
Talk Python Training
Price
Premium
Most MongoDB tutorials stop at the shell and a few CRUD commands. This course treats that as the starting line, not the finish, and builds toward running real, high-performance, document-based applications with Python.
From fundamentals to production
You'll start with what document databases are and where MongoDB sits among other database choices, then get comfortable with MongoDB's native shell and the common CLI and GUI tools around it. From there, the course introduces Beanie — an async ODM for MongoDB built on Pydantic and Python's async/await — and uses it to model a real dataset: hundreds of thousands of PyPI package records.
Key skills covered
Designing data models with Beanie and Pydantic, including when to embed vs. reference data
Wiring Beanie and async MongoDB into a full FastAPI application
Building indexes that turn slow queries into ones running hundreds of times faster
Load-testing performance changes with Locust and custom Python scripts
Safely storing user accounts and passwords in MongoDB
Deploying MongoDB to a production Linux server, step by step
111 lessons in total, aimed at Python developers who want to go well past the basics of MongoDB.
In this course, you will:
How document databases, such as MongoDB, work
Where MongoDB fits in the larger scope of databases used in the world
How to install and configure MongoDB and several management tools and GUIs
A basic set of MongoDB's native shell commands and queries
Foundational technologies such as Pydantic and Python's async and await
How to design data models with Beanie and Pydantic
Understand the tradeoffs when modeling data with documents
Learn when it's a good idea (and when it's a bad one) to embed data within other records
Use ORM-style programming with MongoDB and Beanie
Use more efficient "in-place" operations such as addToSet with Beanie
Design projection classes in Pydantic for improved performance
How to safely store user accounts (namely passwords) in MongoDB
To deeply integrate Beanie and MongoDB with FastAPI
Create complex indexes in MongoDB from Beanie for 1000x performance boosts
Use indexes to enforce data integrity in MongoDB
Safely deploy MongoDB in a self-hosted environment within a cloud provider on multiple Linux machines
Use the load testing framework Locust to probe and test the performance limits of your MongoDB-based web APIs
Talk Python Training is the paid course platform of Michael Kennedy, the host of the long-running Talk Python To Me podcast — one of the most-listened-to podcasts in the Python ecosystem. The course platform extends Michael's interview-based knowledge of the field into structured video courses taught by Michael and a curated set of guest instructors.
The course catalog covers the full Python landscape: web development with Django, Flask, FastAPI, and the broader async-Python stack; data science and pandas; LLM / RAG application development; testing and CI/CD; deployment patterns; the data-engineering side of Python; and a long list of practical Python patterns aimed at working developers. Few platforms cover the language with this much breadth from inside the Python community itself.
The CourseFlix listing under this source carries over 18 Talk Python Training courses spanning that range. Material is paid; Talk Python Training runs on per-course pricing on the original platform. Courses are aimed at developers using Python as a serious primary language rather than as a scripting tool.
What lessons are included in MongoDB with Async Python?
This is a demo lesson (10:00 remaining)
You can watch up to 10 minutes for free. Subscribe to unlock all 111 lessons in this course and access 10,000+ hours of premium content across all courses.
Learn Apache Spark with Python, from DataFrames and MLlib to Spark Streaming and AWS EC2, through mock consulting projects modeling real Big Data work.
Welcome to the best online course for learning about Deep Learning with Python and PyTorch! PyTorch is an open source deep learning platform that provides a sea
How to finally Launch your AI Product (without ripping your hair out).. that makes you money in 30 days (or less). But unlike other AI courses, you won't learn
Master the latest and greatest features in React within the context of a full-stack, real-world app. A realtime, full-stack React app from scratch with a GraphQ
This is a project based course where we build an extensive, in-depth backend API for DevCamper, a bootcamp directory app. We will start from scratch and end up
Programming is fun and profitable. Learning to become a software developer should be equally fun! This course will teach you everything you need to know about t
Python's async and parallel programming support is highly underrated. In this course, you will learn the entire spectrum of Python's parallel APIs. We will star
FastAPI is one of the most exciting new web frameworks out today. It's exciting because it leverages more of the modern Python language features than any other
PyCharm is the premier Python IDE (integrated development environment). You will be hard pressed to find an editor that gives a more holistic way to build.
7h 30m
Frequently asked questions
What are the prerequisites for this course?
The course assumes a basic understanding of Python programming, as it covers advanced concepts such as Python's asyncio and the use of Pydantic. Familiarity with databases, particularly NoSQL concepts, would also be beneficial, given the focus on MongoDB and document databases.
What kind of applications will be built during the course?
The course involves building a variety of applications, starting with simple apps using Beanie, and progressing to more complex projects like modeling PyPI data with MongoDB. There is also a focus on developing a full FastAPI API around the data, demonstrating the integration of Beanie and async MongoDB within FastAPI.
Who is the target audience for this course?
This course is ideal for Python developers interested in leveraging MongoDB for data-driven applications. It's particularly suited for those looking to delve into asynchronous programming and document databases, as well as developers wanting to improve the performance of MongoDB databases or deploy them on production servers.
How does the depth of this course compare to other MongoDB courses?
Unlike many MongoDB courses that only cover basic operations, this course provides practical end-to-end coverage, including advanced topics like performance optimization with large datasets, integration with FastAPI, and deploying MongoDB to production Linux servers. It goes beyond the basics by using real-world data and scenarios.
What specific tools and technologies are covered in the course?
The course covers MongoDB, Beanie (an ODM for MongoDB), and Pydantic. It also includes Python's async and await features, FastAPI for building APIs, and Locust for load testing. Additionally, it addresses MongoDB management tools such as the native shell and the Studio 3T GUI.
What topics are not covered in this course?
The course does not cover SQL-based databases or ORM frameworks like SQLAlchemy. It focuses exclusively on MongoDB as a document database and its integration with Python applications using Beanie and async programming patterns.
What is the expected time commitment for completing the course?
The course consists of 111 lessons, which include hands-on exercises and code-based demos. While the exact runtime is not specified, prospective students should allocate time for both the instructional content and practical application of the concepts in building and testing their projects.
