Django Web Framework¶

About¶

Level: Intermediate to Advanced
Lectures: 30 hours
Self-study: 15 hours
Exercises: 144
Lines of Code to write: 509
Format: e-learning + weekly online teleconference with instructor
Language: English or Polish

Description¶

This practical training course walks participants through building production-ready web applications with Django, following the syllabus from project setup to deployment. Instructor-led modules and hands-on labs cover models and migrations, the admin interface, advanced ORM queries, URL routing and views, templates and forms, authentication and authorization, REST API design, testing strategies, and deployment patterns; students will implement real features, optimize queries, and apply secure, testable workflows used in professional projects.

Advantages¶

The course shortens time-to-market by teaching Django's convention-driven patterns and batteries-included tooling, reducing boilerplate and accelerating feature delivery. Participants gain practical skills for improving code quality, test coverage, observability, and database performance, and they learn repeatable practices for migrations, backup/restore, CI integration, and secure deployment that make teams more productive and systems more maintainable.

Target Audience¶

Backend and full-stack developers who build or maintain Django applications and APIs.
DevOps engineers and SREs who deploy, monitor, and operate Django services in production.
QA engineers and test authors who write integration, system, and API tests that exercise models, migrations, and endpoints.
Application architects and technical leads who define maintainability and deployment standards for teams.
Advanced students and learners seeking practical, production-focused experience building web applications with Python and Django.

Format¶

The course is delivered as a blended learning experience, comprising numerous short videos that progressively introduce concepts and techniques through a series of practical examples. The course format combines e-learning modules with weekly online teleconferences with the instructor for Q&A, discussions, and code reviews.

During the self-study phase, students complete practical exercises that apply the learned techniques. Each exercise is designed to have 100% test coverage, allowing students to verify their solutions. Additionally, students will have access to a spreadsheet to track their progress.

Students will also receive downloadable resources, including code samples, exercise templates, and reference materials to support their learning journey. Since 2015, we have refined our materials based on student feedback to ensure clarity, engagement, and practical relevance. All code listings undergo automatic testing (over 28,000 tests) to ensure accuracy and reliability. All materials, code listings, exercises, and assignments are handcrafted by our trainers without the use of AI. All case studies and examples are based on real-world scenarios drawn from our extensive experience in software engineering.

Working language of the course is either English or Polish.

Course Outline¶

Introduction to Django:
- Examples of services using Django
- Django versions and update strategy
- Installing Django
- Configuration file
- manage.py and its options
- Built-in HTTP server (local listening and listening on all interfaces)
- Run configurations in the IDE
Projects:
- The concept of a Django project
- Creating a new project
- Directory structure
Settings:
- Debug mode and configuration via environment variables
- Secret Key and secrets
- Event logging configuration
- Cache and database configuration
Applications:
- The concept of Django projects and applications
- Creating a new application
- Application structure
- Reusability concept vs. practice
Models:
- Models in Django
- Character, numeric, boolean, special, composite fields, and relationships
- Relationships between models: ForeignKey, OneToOne, ManyToMany
- Field parameters: uniqueness, null values, database indexing, required fields
- Limiting choices
- Automatic date population
- Validators
- Migrations and their management
- Data dump and restore from backup
- Creating custom fields
- Meta class
Admin Panel:
- Creating a superuser
- Registering models
- Admin panel configuration
- Searching, filtering, autocomplete
- Fieldsets, radio buttons, checkboxes
- Custom fields
- StackedInline and TabularInline
- Displaying custom fields using list_display
- Limiting querysets (get_queryset)
- Soft deletion (without removing data from the database)
- Pagination
- Creating custom filters
- Injecting custom JavaScript scripts and CSS styles
- Modifying the admin panel appearance by overriding templates
- Widgets
ORM:
- Creating simple queries using the ORM
- Creating objects, saving to the database, updating
- Retrieving objects, filtering, joining queries, sorting
- Advanced queries: Q objects, F expressions, grouping and aggregations
- Using multiple databases simultaneously
- Database reverse engineering (inspectdb)
- Inspecting database queries
- Model managers
URL Routing:
- Introduction to regular expressions
- Django URL resolving mechanisms
- Connecting views to URLs
- Reverse URL resolution
- Redirects
- Versioning
Views:
- HTTP status codes, request and response headers
- Class-based and function-based views
- Generic views
- Asynchronous views
- Error handling
- Handling different request types (JSON, HTTP, CSV)
- Reading data from requests
- Access-restricting decorators
Templates:
- Template syntax: variables, tags, filters
- URL handling
- Hierarchy, inheritance, and separation of reusable code
- Template tags
- Static files: images, CSS, JavaScript
Forms:
- Form class: types, defining form fields
- Rendering forms
- Form validation
- Error handling
- Creating forms directly from models
- CSRF
Middleware:
- Request processing mechanism
- Creating custom middleware
Locale, i18n, l10n:
- Handling different date formats
- Working with time zones
- Translating templates and field names (gettext)
- Handling different numeric formats
- Translating JavaScript files
Authorization and Authentication in Django Applications:
- Django authentication system (django.contrib.auth)
- Login
- Session mechanism
- Defining user and group permissions
- Restricting access to views
API:
- Creating custom endpoints
- Handling POST, GET, PUT, PATCH, HEAD, OPTIONS requests
- API versioning
- Django REST API (Django Ninja)
- Generating API documentation
- Generating class relationship diagrams (Django Extensions Graph)
- CSRF and CORS
Scripts and Management Commands:
- Creating scripts using Django models and ORM
- Creating custom management commands
Testing:
- Introduction to the django.test module
- TestCase class and Django-specific assertions
- Test client
- Response class
- Fixtures
- Django Debug Toolbar
- CI/CD for Django applications
Deployment:
- Freezing and managing dependencies
- Nginx, uWSGI, async WSGI
- Gunicorn server
- Serving static files and using CDNs (e.g. AWS S3)
- Docker and Kubernetes
- Cache
- Security

Our Experience¶

AATC trainers have been teaching software engineering since 2015. We have already delivered over 11,000 (eleven thousand) hours of software engineering training to more than 32,000 (thirty-two thousand) students worldwide.

Requirements¶

Basic knowledge of Python programming
Familiarity with using an IDE (e.g., PyCharm, VSCode)
Familiarity with using version control systems (e.g., Git)
Basic familiarity with SQL and relational databases
Basic familiarity with HTTP protocol and REST API concepts
Understanding of AI-assisted coding tools (e.g., GitHub Copilot, ChatGPT)

Setup¶

Newest version of Python
IDE of your choice (e.g., PyCharm, VSCode)
Git installed and configured
GitHub account
Web browser (e.g., Chrome, Firefox, Safari, etc.)
SQLite3 or PostgreSQL database installed locally (e.g., using Docker)

Apply¶

If you are interested in taking this course, please contact us at info@astronaut.center