Django Web Development Course

Lesson 1 • HTTP and the Web Request Cycle

Explains HTTP methods, status codes, headers, and cookies as the protocol Django sits on top of. Grounds all later routing and view concepts in real network behaviour.

Lesson 2 • Python Syntax Essentials

Covers variables, data types, control flow, and functions as used in Django internals. Establishes the Python fluency needed for every subsequent chapter.

Lesson 3 • Command Line and Virtual Environments

Introduces shell navigation, pip, and virtual environments to isolate Django projects. Ensures a reproducible development environment before any code is written.

Lesson 4 • HTML, CSS, and the Browser DOM

Reviews semantic HTML structure and CSS selectors needed to build Django templates. Provides the front-end context for understanding template rendering output.

Lesson 1 • URL Routing Fundamentals

Introduces URLconf, path(), and include() to map URLs to views. Provides the routing foundation that all views and templates depend on.

Lesson 2 • Django's MTV Architecture

Explains the Model-Template-View pattern and how it differs from MVC. Clarifies how data, logic, and presentation layers interact in every Django request.

Lesson 3 • Installing Django and Creating a Project

Walks through pip installation, django-admin commands, and initial project scaffolding. Sets up the working environment used throughout the entire course.

Lesson 1 • Migrations and Schema Management

Explains makemigrations, migrate, and how Django tracks schema changes over time. Enables safe, version-controlled database evolution throughout a project.

Lesson 2 • Defining Models and Fields

Teaches model class syntax, field types, and field options such as null, blank, and default. Directly maps Python classes to relational database tables.

Lesson 3 • ORM Queries and QuerySets

Teaches filter(), exclude(), annotate(), and select_related() for efficient data retrieval. Connects query construction to real application data access patterns.

Lesson 4 • The Django Admin Interface

Registers models with the admin site and customises list displays, filters, and search. Provides an immediate management UI for inspecting and editing data.

Lesson 1 • Class-Based Views

Introduces View, TemplateView, and generic display views to reduce boilerplate. Connects OOP inheritance to reusable, composable view logic.

Lesson 2 • URL Parameters and Converters

Teaches path converters, slug fields, and regex-based URL patterns for dynamic routing. Enables views to receive typed parameters directly from the URL.

Lesson 3 • Function-Based Views

Builds views as Python functions that accept a request and return an HttpResponse. Establishes the simplest view pattern before introducing class-based alternatives.

Lesson 4 • Generic Editing Views

Covers CreateView, UpdateView, and DeleteView for model-backed form handling. Reduces repetitive CRUD view code whilst maintaining full customisability.

Lesson 1 • Custom Template Tags and Filters

Shows how to write simple_tag, inclusion_tag, and custom filters in a templatetags module. Extends the template engine for project-specific rendering needs.

Lesson 2 • Template Syntax and Context

Covers variable interpolation, tags, filters, and passing context dicts from views. Establishes the core syntax used in every template throughout the course.

Lesson 3 • Loops, Conditionals, and Filters

Applies {% for %}, {% if %}, and filter chains to render dynamic lists and conditional content. Connects template logic to QuerySet data passed from views.

Lesson 4 • Static Files and Media Handling

Configures STATIC_URL, MEDIA_ROOT, and the {% static %} tag for assets and uploads. Prepares the project for serving CSS, JavaScript, and user-uploaded files.

Lesson 1 • Form Validation and Cleaned Data

Covers is_valid(), cleaned_data, and field-level and form-level clean methods. Ensures all user input is sanitised and validated before reaching the database.

Lesson 2 • File and Image Uploads

Handles multipart form data, FileField, ImageField, and secure file storage. Connects upload handling to MEDIA_ROOT configuration from the templates chapter.

Lesson 3 • Formsets and Dynamic Forms

Introduces formset_factory and BaseFormSet for managing multiple form instances at once. Enables complex data entry patterns such as adding multiple related objects.

Lesson 4 • ModelForms and Form Factories

Teaches ModelForm to auto-generate forms from model definitions and save instances. Reduces duplication between model and form field declarations.

Lesson 1 • Protecting Views with Decorators and Mixins

Applies login_required, permission_required, and LoginRequiredMixin to restrict access. Connects authentication state to URL-level and view-level access control.

Lesson 2 • Django's Built-In Auth System

Covers the User model, authentication backends, and built-in auth views for login and logout. Provides the identity layer that all permission and session features build on.

Lesson 3 • Web Security Hardening

Addresses CSRF, XSS, SQL injection, clickjacking, and secure HTTP headers in Django. Applies defence-in-depth principles to harden the application before deployment.

Lesson 4 • Permissions and Groups

Assigns model-level permissions, creates groups, and checks permissions in views and templates. Enables role-based access control across the entire application.

Lesson 1 • Production Settings and Environment Variables

Separates development and production settings, disables DEBUG, and manages secrets via environment variables. Prevents accidental exposure of credentials and debug information.

Lesson 2 • Caching Strategies

Implements per-view, per-site, and low-level caching using Django's cache framework and Redis. Reduces database load and improves response times under production traffic.

Lesson 3 • WSGI, ASGI, and Application Servers

Configures Gunicorn or uWSGI as the application server and explains ASGI for async support. Bridges Django's Python code to the web server layer.

Lesson 4 • Database Optimisation and Monitoring

Profiles slow queries, adds database indexes, and integrates error tracking and performance monitoring. Ensures the application remains observable and performant at scale.