Software Development
Course

More about Django

Available Intermediate 16 modules 74 lessons
Back to all courses
More about Django

About this course

You have finished the Django Girls tutorial. You have a blog with a Post model, a few function views, some templates, the Django admin and a deployment on a PaaS platform. And then comes the hardest question of all: what now?

This course is the answer. It never re-teaches the Django Girls material - it starts at the exact point where that tutorial stops and takes the same blog project all the way to a real, maintainable, secure and deployable web application.

Every lesson is short and focused, comes with written notes and a YouTube recording. Videos are published gradually, so lessons without a recording yet simply show a placeholder.

Curriculum

Module 0 - Starting line

A short recap of what the Django Girls tutorial left you with, the shared starter repository and a git workflow for the rest of the course.
0.1Where Django Girls ends and where we begin 12 min Video pending 0.2The starter repository 15 min Video pending 0.3Git for your project 18 min Video pending

Module 1 - From tutorial project to a real project

Turn the single-app blog from the tutorial into a project layout that can grow. You move secrets out of settings, split development from production and automate code style.
1.1Project layout that scales 20 min Notes Video pending 1.2Secrets out of settings.py 18 min Notes Video pending 1.3Development and production settings 22 min Notes Video pending 1.4Code style and pre-commit 20 min Notes Video pending

Module 2 - Models and the ORM in depth

The blog gets categories, tags and comments, and you learn to write queries that stay fast. Migrations, managers and reusable base models are covered in detail.
2.1Relations between models 25 min Video pending 2.2Migrations for real 24 min Video pending 2.3QuerySets you actually need 26 min Video pending 2.4Custom managers and querysets 20 min Video pending 2.5Killing N+1 queries 22 min Video pending 2.6Slugs, timestamps and abstract base models 18 min Video pending

Module 3 - Class-based views

Rewrite the Django Girls function views as class-based views and get pagination, forms and CRUD almost for free. You also learn when a plain function is still the better choice.
3.1Why class-based views 16 min Video pending 3.2ListView and DetailView 22 min Video pending 3.3CreateView, UpdateView and DeleteView 24 min Video pending 3.4Mixins and your own base views 20 min Video pending 3.5Function view or class-based view? 14 min Video pending

Module 4 - Users, authentication and permissions

Give the blog real accounts: registration, login, password reset and profiles. You also learn who is allowed to edit what, with permissions and groups.
4.1The custom user model 20 min Video pending 4.2Registration, login and logout 22 min Video pending 4.3Password reset by email 20 min Video pending 4.4Profiles and avatars 20 min Video pending 4.5Permissions and groups 22 min Video pending

Module 5 - Forms and user-generated content

Everything your readers send to the server: comments, uploads and edits. You validate it, moderate it and give clear feedback when something goes wrong.
5.1Form versus ModelForm 20 min Video pending 5.2Comments with moderation 24 min Video pending 5.3File and image uploads 22 min Video pending 5.4Formsets and inline forms 22 min Video pending 5.5The messages framework and CSRF 16 min Video pending

Module 6 - Templates and a modern frontend

Make the blog look and feel like a finished product. Template structure, custom tags, static files, a dark mode and interactive pages with HTMX instead of a SPA.
6.1Template inheritance done right 18 min Video pending 6.2Custom template tags and filters 22 min Video pending 6.3Static files pipeline 20 min Video pending 6.4A CSS framework layout and dark mode 22 min Video pending 6.5HTMX with Django 26 min Video pending

Module 7 - Search, feeds and SEO

Help people and search engines find your posts. From a simple icontains filter to PostgreSQL full-text search, plus feeds, sitemaps and sensible metadata.
7.1Simple search and filtering 20 min Video pending 7.2PostgreSQL full-text search 24 min Video pending 7.3Sitemaps, feeds and robots.txt 18 min Video pending 7.4SEO basics for Django 18 min Video pending

Module 8 - Testing and continuous integration

Stop testing by clicking around. You write tests for the blog with pytest-django, measure coverage and run the whole suite automatically on every push.
8.1Why tests, and what to test first 18 min Video pending 8.2pytest-django 20 min Video pending 8.3Testing models, views and forms 26 min Video pending 8.4Coverage and quality gates 16 min Video pending 8.5Continuous integration with GitHub Actions 22 min Video pending

Module 9 - Performance and caching

Find out what is slow before you optimise anything. You profile the blog, tune the database and add caching at the level where it actually pays off.
9.1Measuring first 20 min Video pending 9.2Database tuning 22 min Video pending 9.3Caching layers 22 min Video pending 9.4Redis as a cache backend 20 min Video pending

Module 10 - Background tasks with Celery

Move slow work out of the request cycle. You set up Celery with Redis, send email in the background, schedule recurring jobs and watch what the workers are doing.
10.1Why you need a task queue 16 min Video pending 10.2Celery and Redis setup 24 min Video pending 10.3Your first tasks 22 min Video pending 10.4Periodic tasks with Celery Beat 20 min Video pending 10.5Monitoring your workers 18 min Video pending

Module 11 - Building an API

When server-rendered pages are not enough, you expose the blog data as an API. Django REST Framework, authentication, documentation and a look at Django Ninja.
11.1Do you need an API? 14 min Video pending 11.2Django REST Framework basics 26 min Video pending 11.3Authentication and permissions for APIs 24 min Video pending 11.4Documenting the API 18 min Video pending 11.5A quick look at Django Ninja 18 min Video pending

Module 12 - Async and real-time (bonus)

A practical introduction to async Django. What async views can and cannot do with the ORM, and how to push live updates to the browser with Channels.
12.1Async views and the ORM 22 min Video pending 12.2WebSockets with Channels 26 min Video pending

Module 13 - Security hardening

Go through the settings and habits that keep a public Django site safe. The deployment checklist, HTTPS, CSP, form abuse protection and the classic web vulnerabilities.
13.1The deployment checklist 18 min Video pending 13.2HTTPS, HSTS and secure cookies 20 min Video pending 13.3Content Security Policy with django-csp 22 min Video pending 13.4Protecting forms from abuse 20 min Video pending 13.5Common Django vulnerabilities 22 min Video pending

Module 14 - Leaving the PaaS: deploying to your own server

Take the blog off PythonAnywhere and run it on a VPS you control. PostgreSQL, Docker, Gunicorn, Nginx, TLS, backups and an automated deployment pipeline.
14.1PaaS versus your own server 16 min Video pending 14.2From SQLite to PostgreSQL 22 min Video pending 14.3Dockerising the project 26 min Video pending 14.4Gunicorn and Uvicorn 22 min Video pending 14.5Nginx and Let's Encrypt 24 min Video pending 14.6Static and media in production 20 min Video pending 14.7Logging, error tracking and backups 24 min Video pending 14.8Automated deployment 24 min Video pending

Module 15 - Capstone

Turn the course project into something of your own. You scope a feature set, review your code like a senior developer would and plan what to learn next.
15.1Extending the blog into your own product 20 min Video pending 15.2Code review checklist 18 min Video pending 15.3Where to go next 15 min Video available

Who it is for

  • Django Girls graduates who do not know what to learn next
  • Self-taught developers with a first Django project already running
  • Backend beginners who want production habits, not just tutorials
  • Anyone who wants to leave a PaaS and run Django on their own server

Prerequisites

  • Completed the Django Girls tutorial (or an equivalent beginner course)
  • Comfortable with basic Python: functions, classes, lists and dicts
  • A working local Python installation and a code editor
  • A GitHub account and the basics of git (clone, commit, push)

What you will learn

  • Structure a Django project so it survives growing beyond one app
  • Model real domains with relations, migrations and efficient queries
  • Replace function views with class-based views where it pays off
  • Add authentication, permissions and user-generated content safely
  • Test your code and run those tests automatically on every push
  • Measure and improve performance with caching and query tuning
  • Move slow work into Celery background tasks
  • Expose a REST API when your project needs one
  • Harden a Django deployment and ship it to your own server

Tools

Django 5/6 PostgreSQL Redis + Celery Docker and docker compose pytest-django and coverage.py Nginx, Gunicorn and Uvicorn GitHub Actions