Resources

Reference material, checklists, and curated tool recommendations for Django engineers. Everything here is practical, tested, and aimed at teams building and maintaining production applications.

Reference library with technical documentation and engineering notebooks

This page collects the reference material that does not fit neatly into a single topic hub but is useful across multiple areas of Django development. Checklists, recommended libraries, architecture patterns, and the practical resources that save time when you need a quick answer rather than a full guide. The resources here are curated from production experience, not aggregated from popularity lists. For the topic-specific deep dives, see the individual hubs: deployment, ORM, security, admin, testing, and performance.

Think of this page as the appendix of a field manual. You come here when you need a quick reference, a checklist to run before a deployment, or a recommendation for a library you have not used before. The guides go deeper. This page gets you oriented.

Checklists

Checklists work because they turn experience into process. The production deployment checklist below covers the critical items that should be verified before any Django application goes live. Each item links to the guide that explains the why and the how.

Pre-deployment checklist

  • Settings isolation verified: DEBUG=False, ALLOWED_HOSTS set, secrets in environment variables. See settings guide.
  • Security headers configured: CSP, HSTS, X-Content-Type-Options, Referrer-Policy. See security checklist.
  • Static files collected and served: collectstatic runs in CI, WhiteNoise or CDN configured. See static files guide.
  • Database connection pooling configured: PgBouncer or connection pool settings verified. See PostgreSQL guide.
  • Authentication reviewed: custom user model confirmed, session settings hardened. See authentication guide.
  • Logging configured: structured logging, error reporting, and log routing verified. See logging guide.
  • Tests passing: full test suite runs in CI before deployment. See testing guide.
Production deployment checklist document with verification items
A production deployment checklist covering settings, security, static files, database, authentication, logging, and testing.

Recommended libraries

These are libraries that have proven reliable in production Django projects. They are well-maintained, well-documented, and solve real problems without introducing unnecessary complexity.

django-debug-toolbar

Query profiling, template analysis, and request inspection for development. Essential for finding N+1 queries and understanding what your views actually do.

django-extensions

Management command enhancements including shell_plus, show_urls, and graph_models. Small utilities that save significant time during development.

factory_boy

Test data factories that replace brittle JSON fixtures with declarative Python objects. The standard approach for test data in modern Django projects.

django-environ

Environment variable parsing with type casting and defaults. Clean interface for settings that need to differ between development and production.

whitenoise

Static file serving for WSGI applications. Serves compressed and cached static files directly from your application without needing Nginx or a CDN for basic setups.

django-csp

Content Security Policy middleware with configuration-based header generation. Makes CSP manageable without hand-writing header strings.

celery

Distributed task queue for background job processing. The production standard for Django applications that need async task execution, scheduled jobs, or long-running operations.

django-filter

Declarative queryset filtering for views and APIs. Reduces boilerplate when building filtered list views or API endpoints with query parameters.

Architecture patterns

These are structural patterns that apply across Django projects regardless of size. They are not prescriptive rules but patterns that consistently work well when projects grow beyond a few apps.

Service layer pattern

Move business logic out of views and into service modules. Views handle request/response. Services handle domain logic. Models handle data persistence. This separation makes logic testable without the HTTP layer and reusable across views, management commands, and background tasks. See the project structure guide for implementation details.

Settings module pattern

Replace a single settings.py with a settings package containing base.py, development.py, and production.py. Base settings define shared configuration. Environment-specific files override what needs to change. The settings guide covers this in full detail.

Query optimization pattern

Define queryset methods on custom managers rather than optimizing in views. A PostManager.published() that includes select_related and filters ensures that optimized queries are used everywhere, not just in the views where someone remembered to add them. The ORM optimization guide covers manager-based patterns.

Django project architecture diagram showing service layer, views, models, and infrastructure
A layered Django architecture: views handle HTTP, services handle business logic, models handle persistence.
⚠

Common resource mistakes

  1. Adding libraries without checking maintenance status, compatibility, and security advisories.
  2. Copying architecture patterns from enterprise Java projects that do not fit Django conventions.
  3. Using complex abstractions for simple CRUD operations that do not need a service layer.
  4. Following checklist items mechanically without understanding why each item matters for your project.

What to read next

For your first production deployment, work through the pre-deployment checklist above and follow the linked guides for each item. For project structure decisions, the project structure guide covers repository layout and app organization. For ongoing maintenance, the changelog tracks what is being refined across the site. Browse the full guides index for the complete list of available references.