Top 8 Recommended Django Self-Study Materials! [November 2024]

Python is the most popular programming language of the world - it is versatile, easy to learn and very powerful!

But one of the primary things you can build with Python is a website! You can use Python for web development.

And to make that easier, you would typically use a framework like Django - simply because that allows you to focus on your core business logic and you don't need to re-invent the wheel and implement all the nitty-gritty technical details from scratch.

This course is about Django - the most popular Python web development framework out there!

Django covers all aspects of web development - from handling requests and responses, over rendering dynamic HTML pages with templates, all the way up to making database access and data management easy. It's all baked in and it's all covered in great detail in this course!

This course teaches Django from the ground up - you don't need to know anything about it to get started. Basic Python and web development knowledge is all you need.

We'll start at the absolute basics and understand how to create Django project, how to run them and how to add features - step by step.

In detail, this course covers:

• Installing Django

• Creating and understanding Django projects

• Understanding URLs, views, requests and responses

• Working with templates and static files like CSS and images

• Working with data and models

• Connecting data with relationships (one-to-many, one-to-one, many-to-many)

• Querying data with Django's powerful model solution

• Adding administration panels to your projects

• Handling user input with forms - manually and with Django's built-in form support

• Advanced features like class-based views (and when to use them)

• Dealing with file uploads and how to serve uploaded files

• Working with sessions

• In-depth deployment instructions and examples

• Different ways of deploying and serving static files and user uploads

• And much more!

All those concepts are taught in great depth and backed up by a complete example course project where we build a "Blog website" from the ground up.

Therefore, you'll learn all the important concepts and the theory and you're also going to be able to see it applied to a real project.

Hence, once you completed the course, you'll have a very solid understanding of Django and you'll be able to dive into your own Django projects!

1. Getting Started
2. Introduction
3. What is Django?
4. The Course Prerequisites
5. What's Inside the Course?
6. Join Our Learning Community!
7. Getting the Most out of the Course
8. Choose Your Course Path!
9. Course Setup
10. Course Setup
11. Module Introduction
12. Installing Python & Django
13. Creating a Django Project
14. Installing an IDE
15. Analyzing the Created Project
16. Starting a Development Server
17. Django Apps
18. Analyzing the Created Project
19. More Advanced Setup Steps
20. Useful Resources & Links
21. URLs & Views
22. Module Introduction
23. Creating a New Project
24. What are URLs & Views?
25. Creating a First View & URL
26. Adding More Views & URLs
27. Dynamic Path Segments & Captured Values
28. Path Converters
29. Adding More Dynamic View Logic
30. Redirects
31. The Reverse Function & Named URLs
32. Returning HTML
33. Practicing URLs, Views & Dynamic View Logic
34. Summary
35. Useful Resources & Links
36. Templates & Static Files
37. Module Introduction
38. Adding & Registering Templates
39. Rendering Templates
40. Template Language & Variable Interpolation
41. Exercise Solution
42. Filters
43. The Django Visual Studio Code Extension
44. Tags & the "for" Tag
45. The URL Tag for Dynamic URLs
46. The "if" Tag for Conditional Content
47. Template Inheritance
48. Exercise Solution
49. Including Partial Template Snippets
50. More on the Django Template Language (DTL)
51. 404 Templates
52. Adding Static Files
53. Adding Global Static Files
54. Adding CSS Styling
55. Building Static URLs Dynamically
56. Summary
57. Useful Resources & Links
58. Course Project: Building a Blog - The Basics
59. Module Introduction
60. Setting Up the Starting Project
61. Planning the Project
62. Adding URLs & Views
63. Adding First Templates
64. Template Content & Static Files
65. Adding Images as Static Files
66. Adding the "All Posts" Page & Style
67. Linking the Pages
68. Adding the "Single Post" Page
69. Adding Dummy Data to the "Views" File
70. Special Template Features & Syntax
71. Adding a Single Post Page
72. Adding a 404 Page
73. Useful Resources & Links
74. Data & Models
75. Module Introduction
76. Different Kinds of Data
77. Understanding Database Options
78. Understanding SQL
79. Django Models
80. Creating a Django Model with Fields
81. Migrations
82. Inserting Data
83. Getting all Entries
84. Updating Models & Migrations
85. Blank vs Null
86. Updating Data
87. Deleting Data
88. Create Instead of Save
89. Querying & Filtering Data
90. "or" Conditions
91. Query Performance
92. Bulk Operations
93. Preparing Templates
94. Rendering Queried Data in the Template
95. Rendering the Details Page
96. Model URLs
97. Adding a Slugfield & Overwriting Save
98. Using the Slug & Updating Field Options
99. Aggregation & Ordering
100. Summary
101. Useful Resources & Links
102. Admin
103. Module Introduction
104. Logging Data Into the Admin Panel
105. Adding Models to the Admin Area
106. Configuring Model Fields
107. Configuring the Admin Settings
108. More Config Options
109. Useful Resources & Links
110. Relationships
111. Module Introduction
112. Understanding Relationship Types
113. Adding a one-to-many Relation & Migrations
114. Working with Relations in Python Code
115. Cross Model Queries
116. Managing Relations in Admin
117. Adding a one-to-one Relation
118. One-to-one Python Code
119. One-to-one & Admin Config
120. Setting-up many-to-many
121. Using many-to-many in Python
122. Many-to-many in Admin
123. Circular Relations & Lazy Relations
124. Summary
125. Useful Resources & Links
126. Course Project - Building a Blog: Data & Models
127. Module Introduction
128. Planning the Data Models
129. Adding a Post Model
130. Author Model & one-to-many
131. Tag Model many-to-many
132. Registering Models for Admin
133. Migrations & Admin Login
134. Adding Data via Admin
135. Configuring the Admin Panel
136. Fetching Posts for Starting Page
137. All Post & Single Post Pages
138. Using Author & Tags Data
139. Summary
140. Useful Resources & Links
141. Forms
142. Module Introduction
143. Starting Setup
144. Adding a Dummy Form
145. Get & Post Requests
146. CSRF Protection
147. Handling Form Submission & Extracting Data
148. Manual Form Validation & the Problems with "that"
149. Using the Django Form Class
150. Validation with Django Forms
151. Customizing the Form Controls
152. Customizing the Rendered HTML
153. Adding Styling
154. Adding More Form Controls
155. Storing Form Data in a Database
156. Introducing Modelforms
157. Configuring the Modelform
158. Saving Data with a Modelform
159. Class Based Views
160. Summary
161. Useful Resources & Links
162. Class Views
163. Module Introduction
164. Adding Templates
165. TemplateView
166. Using the TemplateView
167. Showing a Detail Template
168. The ListView
169. DetailView
170. When to Use Which View
171. FormView
172. CreateView
173. Useful Resources & Links
174. File Uploads
175. Module Introduction
176. Starting Setup
177. Making the File Upload Work
178. Storing Uploaded Files Naive Approach
179. Adding a Form with a Filefield
180. Using Models for File Storage
181. Using an Imagefield
182. Using a CreateView
183. Working with the File Field
184. Serving Uploaded Files
185. Summary
186. Useful Resources & Links
187. Sessions
188. Module Introduction
189. Problem Description
190. What are Sessions?
191. Enabling & Configuring Sessions
192. Adding a New View
193. Storing Data in Sessions
194. Which Kind of Data Should be Stored
195. Using Session Data
196. Safely Accessing Session Data
197. Summary
198. Useful Resources & Links
199. Course Project: Building a Blog - Forms, Files & Sessions
200. Module Introduction

About this course

Ready to learn Django? In this course we will start from the very basics of what Django is to completing and deploying a fully functional, full stack website with the up to date version of Django 5.

The website we will build as we learn will be an online platform where developers from around the world can create a profile and share their work with others.

Who is this course for?

While this course is Beginner friendly, all skill levels can learn here. We won't just be learning the basics, we will be applying what we know to add awesome site features like messaging other users, leaving comments and rating projects and so much more. This course will leave all skill levels with a new load of knowledge and different approaches of completing tasks.

For those who are more advanced and maybe have already built out a few applications, you can simply skip through or fast-forward to get to the "good stuff". In the second half of the course we will work on a voting system, messaging, sending emails and even building out an API. Even if you have done these things already you can see a new approach and build an awesome website in the process.

What Will You Learn?

Setting up a Django Website

Views & URL's

Templates & Template Inheritance

Designing and Modeling data

Create Read Update Delete

Static Files

Installing Themes

Login & Registration

Search & Pagination

Building API's

Class Based Views

Deploying a website

*BONUS - Access to private Discord group

Build a REAL Project

We wont just be learning the basics, we will be applying what we know to add awesome site features like: messaging other users, leaving comments, rating projects and so much more.

Why Django?

1. Scale easily with Django for high traffic websites. This is one of its most popular features. Including built in tools to help you get your site to market fast.

2. Security is a priority when building any website. Django is used by top brands for this reason. It contains built in security features: SQL injection, cross-site request forgery, and cross-site scripting.

3. Easily customizable and versatile for any website and company size.

4. One of Djangos likable features is the community support. You can join forums and Facebook groups for connections and resources.

Django helped me build and sell my first website for $41k

I was searching for a Python framework that would help me build a lab management system (that I then sold to my boss - watch the full story on YouTube: Dennis Ivy - How I Sold My Python/Django Website for $41,000).

I started with Flask, but all it had was a server setup and everything else I would have to figure out on my own.

Then I discovered Django...

It provided me with ALL the tools. Everything from authentication to a templating engine to a great package for a rest API. Added bonus: they have great community support around it and great infrastructure.

I didn't have to worry that it wasn’t scalable,

If it was good enough for YouTube, Spotify, Instagram and all the behemoth of machines, I knew that it would never be an issue for me.

One of the best features about Django is that it has a built in dashboard. You can run one command and already start seeing your data and modify it.

This helped me get the site up and running quicker than expected.

F.A.Q

Q: Will I have support throughout this course?

A: Unfortunately, with over 50k students across all platforms and a full time job, the teacher cannot offer individual help beyond the course itself. You can join the Discord group for additional support from fellow students.

Q: Is the course up to date?

A: Yes this course is currently up to date and compatible with Django 5.0.

Q: Will I always have access to this course when I purchase it?

A: Yes this course will always be up and hosted on Udemy.

1. Introduction
2. Introduction
3. What is Django
4. Prerequisites
5. Environment Setup
6. Source code
7. Installation & Setup
8. The Basics
9. Views & URL's
10. Templates & Template Inheritance
11. Rendering Data to Templates
12. Building our Database
13. Models & Admin Panel
14. Database Relationships
15. Database Queries
16. Create Update Delete (CRUD)
17. Model Forms
18. Create Read Update Delete (CRUD)
19. Static Files & Theme Installation
20. Static Files
21. Theme Installation
22. Add More Apps
23. Users App
24. Add & Render Profiles
25. Signals
26. Authentication
27. User Login, Logout and Flash Messages
28. User Registration
29. Styling Login & Register Page
30. User Actions
31. User Account
32. User Edit Profile
33. User Project CRUD
34. Add, Edit & Delete add skills
35. Search & Pagination
36. Search
37. Pagination
38. Search + Pagination Hacky Fix
39. Reviews & Messages
40. Reviews
41. Messages
42. Sending Emails & Password Reset
43. Sending Welcome Emails
44. Password Reset
45. Building an API
46. Setting up a simple API
47. Django REST Framework & Serializers
48. Nested Serializers & Serializer Method Fields
49. Setting Up Postman
50. Authentication With JSON Web Tokens
51. Sending POST Requests
52. Getting Data from the Frontend & CORS
53. Sending Data from the Frontend
54. Storing JSON Web Tokens
55. Production Preparation & Deployment
56. Code Cleanup & Bug Fixes
57. Connecting a Postgres Database
58. Static Files in S3 Buckets
59. Deploying Project

Python Django 2024 - The Complete Course (MVT, ORM, Auth, ChatGPT & More)

Welcome to this complete Django course for beginners. I will teach you everything you need to know to become an Expert Django developer. You will master the Django web framework.

In this course, I start each new topic with WHAT, WHY, and HOW to clarify everything. You will also learn how to use AI tools like ChatGPT to assist with your Django development to stand out from other Django developers and boost your career. This will help you make your Django development easier and build websites faster. In today’s AI-driven world, companies want Django developers who can use AI to work more efficiently.

After completing all the parts of this course, you will be ready to start freelancing on Django projects or apply for entry-level Django developer jobs.

I am Taranjot Singh, your instructor for this course. I have over 4 years of experience with Django. I have seen new Django versions launching and old features get deprecated. With my experience, I can keep track of all the latest features and best practices. If you enroll in this course, I will keep you updated with all the latest features and best practices.

Before we talk about the course, let’s take a look at some reviews from my students about my courses and teaching style:

- “Your explanation is so simple and easy. This video helps me a lot thank you so much” - Umang Kumar

- “What a lecture... I am just amazed...alhamdulillah. Thanks a lot for your effort sir ” - Sahira Ahmed

- “Your project is helpful bro!!! Thanks for your valuable time.” - Amal Dravid

- “Thanks, it’s a gold mine for a noob like me! <3” - Co_Li

- “Thank you, man. I loved this video!” - Raph Ayor

These are just a few reviews from my other Django courses. I have many more like these, but I can't include all of them here.

This course teaches Django from scratch, requiring only basic Python, HTML, and CSS knowledge. You will start this course first by learning the roots of Django for example What & Why Behind Django Project & Understanding Concepts like Apps Using Real World Examples. We will deep dive into every topic, exploring how it works behind the scenes. We will also thoroughly understand database interactions in Django, including how ORM works and generates SQL. Each section is connected for example before learning about Authentication & How it works behind the scenes. We will first learn about Cookies, Middlewares & Sessions to understand how authentication works behind the scenes. We need to learn cookies, middlewares & sessions because they are the root of Django's built-in authentication. This course isn’t for those who want to quickly learn Django but is for those who want to deep dive & want to master Django because this course is going to be very large.

Here’s what you’ll learn in this first part of the course:

• Installing Django & Course Setup.

• URLs & Views.

• Templates, Context Processors & Static Files.

• Databases, ORM & Models.

• Admin & ModelAdmin.

• Working with Forms & ModelForms.

• Cookies in Django.

• Middlewares in Django.

• Working with Sessions.

• Authentication & Authorization in Django.

• Pagination.

• Relationships in Django.

• Handling File Uploads & Images.

• Adding More Features.

• Deep Dive into Class-Based Views.

• Using ChatGPT to Boost Your Development

This course is not just about theory. You will build an one major project: An advanced Blog website which will includes all features that modern blog applications have. By working on these projects, you will apply what you learn in a realistic environment.

Is this course for you?

• Beginners: Perfect if you’re starting with zero knowledge.

• Intermediate Users: Ideal if you want to deepen your understanding of Django.

• Advanced Users: Great for those seeking in-depth knowledge on specific topics like ORM, authentication, and more.

This course comes with a 30-day money-back guarantee. Don’t miss the opportunity to become an expert Django developer. Enroll now and let's get started on your journey to mastering Django!

1. Introduction
2. Introduction
3. Django - What & Why
4. Resources To Learn More About Django
5. Watch Before You Start
6. Installing Django & Course Setup
7. What To Skip
8. Installing Python
9. Installing Django & Vscode
10. Creating Our First Django Project & Analyzing It
11. Running Server
12. Django Apps - What & Why
13. Creating Our First App & Analyzing It
14. Download Source Code
15. Helpful Resources, Tips & Links
16. URLs & Views
17. What Are URLs & Views
18. Creating Our First URL & View
19. How Everything Is Working Internally & Reason Behind URLs File Inside App
20. Returning HTML As Response
21. Dynamic URLs
22. Creating Our First Dynamic URL & Understanding Path Converters
23. Implementing Logic For Showing Single Post
24. Exploring HttpResponse Subclasses
25. Redirecting User
26. Reverse Function & Named URLs
27. Helpful Resources Tips & Links
28. Templates, Context Processors & Static Files
29. Module Introduction
30. Download Template files
31. Adding & Rendering Templates
32. Understanding Template Settings & Templates Namespacing
33. Django Template Language & Passing Context
34. What Are Tags & For Tag
35. If Else Tag
36. For Empty Tag & For Loop Variables
37. Filters In Django Template Language
38. Showing Single Post
39. URL Tag
40. Understanding DIRS Settings
41. Template Inheritance
42. Working With Static Files
43. Global Static Files
44. Adding Templates & Styling To Our Project
45. Includes In Django Template Language
46. Custom 404 Page & Raising Http404
47. Context Processors
48. Important Note
49. Helpful Resources, Links & Tips
50. Databases, ORM & Models
51. Databases Quick Primer
52. Understanding ORM & Django ORM
53. Understanding Models
54. Creating Our First Model
55. Installing Extension
56. Migrations
57. Showmigrations Command & Re-Migrations
58. Save( ) & Create( ) Method
59. Connection.queries & Watching SQL Generated Behind The Scenes
60. All() Method & Deep Diving Into QuerySets
61. Understanding Get, Filter & Exclude QuerySet API Methods
62. Exploring More QuerySet API Methods
63. Querying Using AND OR Operators
64. Q Object
65. Limiting QuerySets
66. Field Lookups
67. QuerySets Are Lazy
68. Updating Single Row & Multiple Rows
69. Deleting Single Row & Multiple Rows
70. Fetching & Rendering Data In Templates
71. Fetching Post From Database & Rendering It Inside Template
72. get_object_or_404
73. Understanding and Deep Diving Into Aggregation
74. Helpful Resources, Links & Tips
75. Admin & ModelAdmin
76. Module Introduction
77. Creating Super User & Accessing Admin Panel
78. Registering Model Inside Admin & __str__ Method
79. Exploring Admin Panel
80. ModelAdmin Class & ModelAdmin Options
81. Listfilter & Search Functionality
82. Changing Header Title & Site Title
83. Helpful Resources, Links & Tips
84. Working With Forms & ModelForms
85. Module Introduction
86. Understanding Django Forms & Project Setup
87. Creating & Rendering Form
88. Understanding GET & POST Method
89. Understanding CSRF Attack & CSRF Tokens
90. Handling Form Submission
91. Understanding How Form Submission Works Step by Step
92. Exploring More Form Fields
93. Core Field Arguments
94. Output Styles
95. Rendering Form Fields Manually
96. Looping Through Form Fields
97. Widgets In Django Forms
98. Styling Django Form: Custom CSS Classes and IDs on Form Fields
99. Custom Validation On Complete Form
100. Custom Validation On Single Form Field
101. Styling Form Errors
102. CRUD Using Django Forms API
103. Introduction To ModelForms
104. Creating Our First ModelForm
105. Save( ) Method On ModelForm
106. Custom Labels, Help Texts, Error Messages, and Widgets in Django ModelForms
107. CRUD Using ModelForms
108. Using Clean Method & Custom Validators In ModelForms
109. Fields & Exclude Attribute
110. Helpful Resources, Links & Tips
111. Cookies In Django
112. Understanding Cookies & How Cookies Works
113. Working With Cookies In Django
114. Using Cookies With Render Function
115. Cookies Limitations
116. Helpful Resources, Links & Tips
117. Middlewares In Django
118. Module Introduction
119. Understanding Middlewares & How They Work
120. Custom Function Based Middleware
121. Custom Class Based Middleware
122. Returning Response From Middleware & Middleware Ordering
123. Understanding All Middleware Hooks
124. Exploring Built-In Middlewares
125. Helpful Resources, Links & Tips
126. Working With Sessions
127. Module Introduction
128. Understanding Sessions & How Sessions Work
129. Working With Sessions
130. Flush Method
131. Exploring Session Methods
132. Session Modified
133. Session Settings
134. Helpful Resources, Links & Tips
135. Authentication & Authorization
136. Module Introduction
137. Enabling Authentication & Creating An App
138. How Authentication Works
139. Implementing User Registration
140. Customizing UserCreationForm & Getting More User Data While Registration
141. Understanding & Implementing Login Functionality Step By Step
142. Customizing AuthenticationForm
143. Fixing A Field
144. Limiting Access To Logged-In Users & Anonymous Users
145. Authentication Data In Templates
146. Implementing Logout Functionality Step By Step
147. Using Built-In Authentication Views
148. Customizing Built-In Authentication Views
149. redirect_authenticated_user
150. Helpful Resources, Links & Tips
151. Pagination
152. Module Introduction
153. Pagination Logic In Views
154. Pagination Logic In Template
155. Important Note
156. Orphans & allow_empty_first_page arguments
157. Relationships In Django
158. Module Introduction
159. Exploring & Understanding Different Relationship Types
160. Understanding & Adding One-To-One Relationship
161. on_delete Argument
162. Querying Using Relationships
163. Related Objects Query
164. Adding Many-To-One Field
165. Querying Using Many To One & Related Object Query
166. Understanding & Adding Many-To-Many Relationship
167. Working With Many-To-Many Field
168. Showing Tags On Post Page
169. Adding User Field To Comments & Rendering Comments On Post Page
170. A Special Note
171. Helpful Resources, Links & Tips
172. Handling File Uploads
173. Module Introduction
174. Project Setup
175. Creating Model With FieldField
176. Creating Form & Handling File Upload
177. Using ImageField
178. Serving Files
179. Adding & Serving Post Image In Blog Project
180. Helpful Resources, Links & Tips
181. Adding More Features
182. Adding Search Functionality
183. Improving Search Functionality
184. Handling Root URL
185. Not Showing Pagination If Less Posts
186. Deep Diving Into Class Based Views (CBVs)
187. Module Introduction
188. Deep Dive Into Class Based Views
189. View Class (Base Views)
190. TemplateView (Base Views)
191. RedirectView (Base Views)
192. ListView (Generic Display Views)
193. DetailView (Generic Display Views)
194. FormView (Generic Edit Views)
195. CreateView (Generic Edit Views)
196. UpdateView (Generic Edit Views)
197. DeleteView (Generic Edit Views)
198. Converting Blog Project Function Based Views Into Class Based Views
199. Converting Blog Project Function Based Views Into Class Based Views Part 2
200. Pagination With Class Based Views

Welcome to "Building Web Applications with Django and PostgreSQL"! This course is designed to provide you with a comprehensive understanding of how to develop web applications using the Django web framework in combination with the PostgreSQL database. Django is a popular web framework written in Python that allows developers to build robust and scalable web applications quickly and efficiently, while PostgreSQL is a powerful open-source relational database management system known for its reliability and performance.

In this course, you will learn how to build web applications from scratch using Django and PostgreSQL. You will start with the fundamentals of Django, including setting up a development environment, creating models, views, and templates, and handling user authentication and authorization. You will also learn how to work with Django's built-in admin interface and form files.

learn what is Generative AI for future learning

As you progress, you will dive deeper into advanced topics, such as working with Django's ORM (Object-Relational Mapping) to interact with the PostgreSQL database, handling form submissions, and integrating third-party libraries. You will also learn best practices for structuring Django projects, handling user sessions, and securing your web applications against common web vulnerabilities.

Throughout the course, you will work on practical projects that will allow you to apply the concepts you've learned and build real-world web applications. You will also gain hands-on experience in using PostgreSQL as your database backend, including designing database schemas, performing CRUD (Create, Read, Update, Delete) operations, and optimizing database performance.

By the end of this course, you will have a solid foundation in building web applications with Django and PostgreSQL. You will be able to create dynamic and interactive web applications that are secure, scalable, and maintainable, making you a skilled and proficient web developer.

1. Getting started
2. Introduction
3. Getting started on Windows, macOS, and Linux
4. How to ask great questions
5. FAQs
6. Learn What is Generative AI / Gen AI
7. Setting up a Python development
8. Installing Python
9. Installing PyCharm IDE for development
10. Creating the first Python project
11. Write and Run Hello World program
12. Command line basics
13. Installation and access pip command
14. Download Resources and Reference Project Source Code
15. Download Resources and Reference Project Source Code
16. Django to PostgreSQL database connection Project Settings file
17. Django setting up the project
18. Introduction to web framework and Django
19. Installing Django and setting up a project
20. Understanding Django architecture and structured
21. Creating a simple Django app
22. Building a Django App with PostgreSQL
23. Introduction to PostgreSQL and its advantages for web applications
24. Installing PostgreSQL and setting up a database
25. pgAdmin Secure login and create database
26. Connection Django to PostgreSQL
27. Creating a Basic HTTP view method request
28. URL pattern on app
29. Include apps to project urls
30. Installing the psycopg2 module for DB connection
31. Django Models and ORM (Object Relational Mapping)
32. Defining models and creating database tables
33. Using Djangos built-in ORM to interact with the database
34. Migration to create DB tables
35. Assessment Test
36. Solution for an Assessment Test
37. Working with Admin Module
38. Creating Superuser as Admin
39. Authentication and Authorization
40. User access permissions
41. Registering user models to the admin Dashboard
42. Creating data using CRUD functionality
43. View data on the PostgreSQL database table
44. Django Views and Templates
45. Understanding the MVC - MVT
46. Creating views and handling HTTP requests and rendering templates
47. Creating a template with HTML page
48. Building dynamic form and handling
49. Django Forms and Design
50. Creating Bootstrap template
51. Applying Bootstrap to Django form
52. Creating Stunning Product Card items
53. Django Project: Registration forms - Real world
54. Creating model
55. Creating forms
56. Creating views
57. Applying ORM - migrations
58. Creating my_form template
59. Adding urls
60. Creating success_view template
61. Project urls update and adding Installed apps
62. Run project and submit data to database
63. Django Reports
64. Creating report_view method
65. Creating report_template
66. Update urls pattern
67. Run project and test reports

Welcome to the advanced course on how to Build a Backend REST API using Python, Django (3.2), Django REST Framework (3.12), Docker, GitHub Actions, Postgres and Test Driven Development!

Whether you’re a freelance programmer, tech entrepreneur, or just starting out building backends - this course will help lay the foundation of your knowledge base and give you the tools to advance your skills with some of the most in-demand programming languages today.

APIs are the unsung heroes behind the technologies that we all love and use religiously.

One of the most critical components for any tech-based business is an API. So knowing how to create an API from start to finish is a vital skill to have as a developer. You cannot build a successful app without a backend REST API!

In this course I’ll show you how to build an advanced API that handles creating and updating user profiles, changing passwords, creating objects, uploading images, filtering and searching objects, and more.

The best way to learn anything is to do it. So the practical application of the course -- the project that you’ll build along side me -- is an API. A recipe API, to be specific.

You will learn how to build an advanced recipe API that allows you to upload and store some of your favourite recipes from photos and the web.

You’ll learn how to create objects i.e. recipes with titles, price points, cooking times, ingredients and tags like “comfort food”, “vegan” or “dessert”. Think of it as a virtual recipe box.

By the end of this course you will have built a fully functioning REST API that can handle:

• User authentication

• Creating objects

• Filtering and sorting objects

• Uploading and viewing images

You’ll also learn, in detail how to:

• Setup a project with Docker and Docker-Compose

• Configure GitHub Actions to automatically run linting and unit tests

• Write unit tests using the Django Test Framework

• Apply best practice principles including Test Driven Development  

• Handle uploading media files with Django

• Customize the Django admin

• Configure a Postgres database

This course has one singular focus: To teach you how to create an advanced API from start to finish using best practice principles and Test Driven Development.

This course is NOT FOR YOU:

• If you’re looking for a course to build an API, a front end, and deployment

• If you’re looking to build 10 different apps in one course

• If you want to learn lots of different technologies and approaches to app development in general

This is a hands-on course, with a bit of theory and lots of opportunities to test your knowledge.

The content is challenging but rewarding. Ready for it? Let’s dive in!

**PLEASE NOTE: You cannot run Docker on Windows 10 Home edition. This is because Windows 10 Pro or Enterprise is required in order to use Hyper-V which Docker uses for virtualization. To take this course you have two options. These are covered in Lecture 6, which is free to preview before purchasing the course.

1. Introduction
2. Technical requirements
3. API details & Upgrades
4. Course structure
5. Getting help
6. App Design
7. App overview
8. Technologies
9. Django project structure
10. Test Driven Development
11. What is Test Driven Development?
12. Test Driven Development Quiz
13. System Setup
14. What to install
15. Setup confirmation [Follow Along]
16. Project Setup
17. New project overview
18. Create GitHub project [Follow Along]
19. Docker and Django
20. Define Python requirements [Follow Along]
21. Create project Dockerfile [Follow Along]
22. Create Docker Compose configuration [Follow Along]
23. Linting and Tests
24. Configure flake8 [Follow Along]
25. Create Django project [Follow Along]
26. Run project with Docker Compose [Follow Along]
27. Project setup overview
28. Quiz: Docker and Docker Compose
29. Configure GitHub Actions
30. What is GitHub Actions
31. Configuring GitHub Actions
32. Create GitHub Actions config [Follow Along]
33. UPDATE: docker-compose removed
34. Test GitHub Actions [Follow Along]
35. Quiz: GitHub Actions configuration
36. Test Driven Development with Django
37. Testing in Django
38. Write a test [Follow Along]
39. Write a test using TDD [Follow Along]
40. Mocking
41. Testing web requests
42. Common testing problems
43. Quiz: TDD with Django
44. Configure Database
45. Database architecture overview
46. Add database service [Follow Along]
47. Database configuration with Django
48. Install PostgreSQL database adaptor [Follow Along]
49. Configure database in Django [Follow Along]
50. Fixing database race condition
51. Create core app [Follow Along]
52. Write tests for wait_for_db command [Follow Along]
53. Add wait_for_db command [Follow Along]
54. Database migrations
55. Update Docker Compose and CI/CD [Follow Along]
56. Summary
57. Create User Model
58. The Django user model
59. Design custom user model
60. Add user model tests [Follow Along]
61. Implement user model [Follow Along]
62. Normalize email addresses [Follow Along]
63. Require email input [Follow Along]
64. Add superuser support [Follow Along]
65. Test user model [Follow Along]
66. Summary of Create User Model
67. Setup Django Admin
68. Django admin overview
69. Write tests for listing users [Follow Along]
70. Make Django admin list users [Follow Along]
71. Support modifying users [Follow Along]
72. Support creating users [Follow Along]
73. API Documentation
74. Importance of API documentation
75. Auto docs with DRF
76. Quiz: Documentation
77. Install drf-spectacular [Follow Along]
78. Configure URLs [Follow Along]
79. Test Swagger UI [Follow Along]
80. Summary
81. Build user API
82. User API design
83. Create user app [Follow Along]
84. Write tests for create user API [Follow Along]
85. Implement create user API [Follow Along]
86. Authentication
87. Quiz: Authentication
88. Write tests for token API [Follow Along]
89. Implement token API [Follow Along]
90. Write tests for manage user API [Follow Along]
91. Implement manage user API [Follow Along]
92. Review user API in browser [Follow Along]
93. Summary
94. Build recipe API
95. Recipe API design
96. APIView vs Viewsets
97. Write test for recipe model [Follow Along]
98. Implement recipe model [Follow Along]
99. Create recipe app [Follow Along]
100. Write tests for listing recipes [Follow Along]
101. Implement recipe listing API [Follow Along]
102. Write tests for recipe detail API [Follow Along]
103. Implement recipe detail API [Follow Along]
104. Write tests for creating recipes [Follow Along]
105. Implement create recipe API [Follow Along]
106. Add additional tests [Follow Along]
107. Review recipe API in browser [Follow Along]
108. Summary
109. Build tags API
110. Tags API design
111. Add tag model [Follow Along]
112. Write tests for listing tags [Follow Along]
113. Implement tag listing API [Follow Along]
114. Write tests for updating tags [Follow Along]
115. Implement update tag API [Follow Along]
116. Write tests for deleting tags [Follow Along]
117. Implement delete tag API [Follow Along]
118. Nested serializers
119. Write tests for creating tags [Follow Along]
120. Implement create tag feature [Follow Along]
121. Write tests for updating recipe tags [Follow Along]
122. Implement update recipe tags feature [Follow Along]
123. Review tags API in browser [Follow Along]
124. Summary
125. Build ingredients API
126. Ingredients API Design
127. Add ingredient model [Follow Along]
128. Write tests for listing ingredients [Follow Along]
129. Implement ingredient listing API [Follow Along]
130. Write tests for updating ingredients [Follow Along]
131. Implement update ingredient API [Follow Along]
132. Write tests for deleting ingredients [Follow Along]
133. Implement delete ingredient API [Follow Along]
134. Write tests for creating ingredients [Follow Along]
135. Implement create ingredients feature [Follow Along]
136. Write tests for updating recipe ingredients [Follow Along]
137. Implement update recipe ingredients feature [Follow Along]
138. Refactoring
139. Refactor recipe views [Follow Along]
140. Review ingredient API in browser [Follow Along]
141. Summary
142. Recipe image API
143. Recipe image API design
144. Add image handling dependencies [Follow Along]
145. Static files with Django and Docker
146. Configure project for static files [Follow Along]
147. Modify recipe model [Follow Along]
148. Write tests for uploading images [Follow Along]
149. Implement image API [Follow Along]
150. Review image uploading in browser [Follow Along]
151. Summary
152. Implement filtering
153. Filtering design
154. Add tests for filtering recipes [Follow Along]
155. Implement recipe filter feature [Follow Along]
156. Add tests for filtering tags and ingredients [Follow Along]
157. Implement tag and ingredient filtering [Follow Along]
158. Review filtering in browser [Follow Along]
159. Summary
160. Deployment
161. Deployment plan
162. Django deployment overview
163. Add uWSGI to project [Follow Along]
164. Create proxy configs [Follow Along]
165. Create proxy Dockerfile [Follow Along]
166. Handling configuration
167. Create docker compose config [Follow Along]
168. Update Django settings [Follow Along]
169. Creating a virtual server
170. Create AWS account and user [Follow Along]
171. Upload SSH Key to AWS [Follow Along]
172. Create EC2 instance [Follow Along]
173. Setup GitHub deploy key [Follow Along]
174. Install Docker, Compose and Git [Follow Along]
175. Clone and configure project [Follow Along]
176. Run service [Follow Along]
177. Updating service [Follow Along]
178. Deployment summary
179. Summary
180. Course overview
181. Upgrades
182. Upgrading to Django 4 [Follow Along]