1. Introduction & Fundamentals

• What is Django — history and core philosophy
• MVT architecture (Model-View-Template) and differences from MVC
• Why choose Django — use cases and trade-offs
• Installing Python, pip, virtual environments (venv, virtualenv, pipenv, poetry)
• Installing Django and checking versions
• Creating projects and apps: django-admin, startproject, startapp
• Project structure: manage.py, settings.py, urls.py, wsgi.py, asgi.py
• Basic development server and workflow
• Settings modules, environment-specific settings, configuration patterns

2. URLs, Views & Templates

• URL routing: path(), re_path(), include()
• Named URL patterns, reverse() and reverse_lazy()
• Function-Based Views (FBV): request objects, HttpResponse, shortcuts
• Class-Based Views (CBV): View, TemplateView, RedirectView
• Generic CBVs: ListView, DetailView, CreateView, UpdateView, DeleteView
• Mixins: LoginRequiredMixin, PermissionRequiredMixin, ContextMixin
• View dispatch, get/post handlers, form_valid/form_invalid hooks
• Template system: template loading, template loaders, template inheritance
• Django Template Language (DTL): tags, filters, custom tags, custom filters, inclusion tags, assignment tags
• Context processors and request context
• StreamingHttpResponse, FileResponse, JsonResponse

3. Models & ORM

• Defining models: fields, options, __str__
• Field types: CharField, TextField, IntegerField, BooleanField, DateField, DateTimeField, EmailField, URLField, DecimalField, FloatField, BinaryField, UUIDField
• Relationship fields: ForeignKey, OneToOneField, ManyToManyField, through tables
• Meta options: db_table, ordering, unique_together, indexes, verbose_name, abstract, managed
• Model methods, properties, managers, custom managers, queryset methods
• Migrations: makemigrations, migrate, squashmigrations, migration graph, data migrations, RunPython
• QuerySet API: filter, exclude, get, all, order_by, values, values_list, distinct, count, exists
• Lookups and field transforms: icontains, startswith, range, in, isnull
• F expressions, Q objects, combining queries, conditional expressions
• Annotate, aggregate, Sum, Avg, Count, Min, Max, Window functions
• select_related vs prefetch_related and query optimization
• Raw SQL and raw() queries, executing custom SQL safely, connection.cursor()
• Transactions and atomic blocks, savepoints, isolation levels
• Database routers for multi-db setups

4. Forms, Validation & File Uploads

• html forms and CSRF protection
• Django forms.Form and forms.ModelForm
• Field types, widgets, custom widgets, widget attributes
• Form validation: clean_field, clean(), raising ValidationError
• Formsets and modelformsets, inline formsets
• Handling file uploads: FileField, ImageField, MEDIA_ROOT, MEDIA_URL
• Streaming uploads, large file handling, chunked uploads
• Third-party form helpers (django-crispy-forms, django-widget-tweaks)

5. Admin Interface

• Enabling and customizing the admin site
• ModelAdmin options: list_display, list_filter, search_fields, ordering
• Inlines: TabularInline and StackedInline
• Admin actions, custom actions, permissions in admin
• Admin site branding, custom templates and CSS
• Third-party admin enhancements (django-grappelli, django-suit)

6. Authentication & Authorization

• Built-in User model, UserManager, permissions framework
• Login, logout, password hashing, password reset and change
• Authentication backends and custom backends
• Permissions, groups, object-level permissions (django-guardian)
• Custom user models: AbstractUser vs AbstractBaseUser
• Social authentication and OAuth (django-allauth, python-social-auth)
• Two-factor authentication and MFA integrations

7. APIs and Django REST Framework (DRF)

• DRF basics: serializers, views, viewsets, routers
• Serializers: Serializer, ModelSerializer, field-level validation, nested serializers
• APIView, GenericAPIView, mixins, ViewSets, ModelViewSet
• Authentication for APIs: Token, Session, JWT, OAuth2
• Permissions and throttling, rate limiting
• Pagination, filtering, search, ordering in APIs
• Browsable API, schema generation (OpenAPI / Swagger), API documentation (drf-yasg, drf-spectacular)
• API versioning and backward compatibility strategies
• GraphQL with Django (Graphene-Django, Ariadne)
• Async APIs and ASGI-based frameworks integration

8. Middleware & Request/Response Processing

• Built-in middleware (security, sessions, common, csrf, authentication)
• Order of middleware and effect on request/response
• Writing custom middleware (sync and async)
• Error handling and custom exception middleware

9. Caching & Performance

• Django caching framework (per-site, per-view, template fragment caching)
• Cache backends: Memcached, Redis, local-memory, database
• Low-level cache API and versioning cache keys
• Template fragment caching and cache invalidation strategies
• Query optimizations, using select_related and prefetch_related
• Database indexing and explain plans
• Profiling and performance tools (django-debug-toolbar, silk)

10. Security

• CSRF protection, XSS prevention, clickjacking protection
• Use of ORM to avoid SQL injection
• Secure session settings, SESSION_COOKIE_SECURE, CSRF_COOKIE_SECURE
• HTTP headers: Content-Security-Policy, HSTS, X-Frame-Options
• Password policies, password hashing algorithms and upgrades
• Input validation and safe file handling
• Dependency auditing and updating security fixes

11. Asynchronous, Channels & Real-time

• ASGI vs WSGI
• Async views, async ORM considerations
• Django Channels for WebSockets, background consumers, routing
• Channel layers, Redis as channel layer backend
• Real-time patterns: notifications, live updates, presence

12. Background Tasks & Scheduling

• Celery with Django: tasks, workers, beat scheduler
• Alternatives: Huey, Dramatiq, RQ (Redis Queue)
• Periodic tasks, crontab schedules, retry strategies
• Task result backends, monitoring (Flower, Celery Flower)

13. Internationalization & Localization

• Translation tools: makemessages, compilemessages
• Using ugettext_lazy, translation in templates and models
• Locale middleware, LANGUAGE_CODE, time zones and USE_TZ
• Formatting dates, numbers, pluralization rules

14. Testing

• Unit tests with Django TestCase
• Client and API testing, DRF test tools
• Fixtures, factories (Factory Boy), mocks and patching
• Integration tests, end-to-end tests, Selenium, Playwright
• Continuous Integration pipelines and test automation

15. Media, Static Files & Storage Backends

• Static files handling, collectstatic, whitenoise
• Media files: serving in dev vs production
• Third-party storage backends: S3 (django-storages), Google Cloud Storage, Azure Blob
• Signed URLs, CDN integration, cache headers
• Image processing with Pillow, thumbnail generation (sorl-thumbnail, easy-thumbnails)

16. Third-Party Integrations & Ecosystem

• django-allauth, social auth, OAuth2 providers
• Payment gateways: Stripe, PayPal, Braintree
• Search engines: Elasticsearch / OpenSearch, Haystack, Whoosh
• Full-text search, search indexing strategies
• Analytics and tracking integrations
• Email backends, transactional email services: SendGrid, Mailgun, Amazon SES
• Monitoring & observability: Sentry, Prometheus exporters

17. Application Architecture & Scaling

• Monolith vs microservices and Django considerations
• Reusable apps and app packaging
• Service separation: API service, worker service, frontend service
• Load balancing, horizontal scaling, sticky sessions
• Database scaling: read replicas, sharding strategies
• Caching layers and CDN strategies

18. Deployment & DevOps

• Preparing for production: DEBUG, ALLOWED_HOSTS, SECRET_KEY management
• WSGI servers: Gunicorn, uWSGI; ASGI servers: Daphne, Uvicorn
• Reverse proxy and static serving with Nginx
• Containerization with Docker, Docker Compose, Kubernetes
• Platform-as-a-Service: Heroku, PythonAnywhere, Render
• Cloud deployments: AWS (Elastic Beanstalk, ECS, EKS), GCP, Azure
• CI/CD pipelines, automated migrations, blue/green and canary deploys

19. Logging, Monitoring & Observability

• Python logging configuration and handlers
• Structured logging, context-aware logs
• Error reporting: Sentry and integrations
• Metrics: Prometheus exporter and Grafana dashboards
• Health checks and readiness/liveness probes

20. Compliance, Data Protection & Best Practices

• GDPR and personal data handling patterns
• Data retention and deletion policies
• Audit logs, change tracking, and data provenance
• Secure defaults and least privilege principles

21. Patterns, Techniques & Utilities

• Signals: pre_save, post_save, m2m_changed and cautionary patterns
• Custom management commands
• Context managers, middleware patterns, decorator patterns
• Using enums and choices for model fields
• Feature flags and toggles (django-waffle)
• Pagination strategies for large datasets

22. Learning, References & Further Reading

• Official docs: djangoproject.com documentation
• Books, tutorials, video courses, and blog series
• Community channels: Django Forum, Reddit r/django, Stack Overflow
• Contributing to Django core and reading release notes

Note: This list is intentionally broad and includes most commonly studied topics and advanced topics used in production. Use find-in-page to locate specific items quickly.