Django monitoring / production checklist

Django monitoring checklist: 12 checks for a clear production overview

Use this practical runbook to find the gaps between “the process is running” and “I can explain what users are experiencing.” Your progress stays in this browser.

No signup · No data sent · Last reviewed July 30, 2026

The short answer

Monitor the failure, its cause and its customer impact

A useful Django production overview combines three layers: availability tells you whether the application can serve traffic, application signals explain errors and slow requests, and journey signals show whether real users were affected.

Django’s official deployment checklist tells developers to review logging, verify it after traffic arrives and configure error reporting. It also warns that email error reports do not scale well. This checklist turns that foundation into an operational workflow you can test after every meaningful release.

Primary references: Django deployment checklist, Django error reporting and Django logging documentation.

Minimal readiness endpoint

Check the database without publishing its failure details

Use readiness to decide whether this instance can serve useful traffic. The example performs one bounded database query and returns only ok or unavailable.

Keep liveness separate. A process may still be alive during a short database outage. Restarting every instance can make a dependency incident worse rather than better.
health.py
from django.db import connection
from django.db.utils import OperationalError
from django.http import JsonResponse
from django.views.decorators.http import require_GET


@require_GET
def readiness(request):
    try:
        with connection.cursor() as cursor:
            cursor.execute("SELECT 1")
    except OperationalError:
        return JsonResponse(
            {"status": "unavailable"},
            status=503,
        )
    return JsonResponse({"status": "ok"})
urls.py
from django.urls import path
from .health import readiness

urlpatterns = [
    path("ready/", readiness, name="readiness"),
]

If PostgreSQL is not the only essential dependency, test the others deliberately—but put a strict timeout around every network call. A readiness endpoint must not become a new source of slow requests.

A 30-minute implementation order

Get useful coverage before adding a complex stack

  1. 0–5 MIN

    Verify Django itself

    Run python manage.py check --deploy against production settings and review every warning.

  2. 5–10 MIN

    Capture one exception

    Send a controlled test failure and verify the traceback, environment and alert recipient.

  3. 10–20 MIN

    Add outside-in checks

    Monitor the public URL and add a bounded readiness endpoint for essential dependencies.

  4. 20–30 MIN

    Mark impact

    Add a release identifier and one meaningful user-journey event, then test the complete workflow.

Match depth to complexity

When this checklist is enough—and when it is not

SMALL DJANGO APP

Start with errors, uptime and releases

A focused dashboard can be enough when one application, database and small team share a straightforward deployment path.

GROWING PRODUCT

Add route and journey baselines

Measure request health, background jobs, browser errors and the product events that reveal customer impact.

DISTRIBUTED SYSTEM

Use full observability

Add metrics, distributed traces, profiling and infrastructure telemetry when a request crosses services or simple context cannot locate the bottleneck.

Django monitoring checklist FAQ

Questions that prevent noisy or unsafe monitoring

What is the minimum monitoring for a Django application?

At minimum, capture unhandled exceptions, retain searchable application logs, check the public URL from outside the stack, expose a bounded readiness endpoint, mark releases and verify that alerts reach a person who can act.

Does Django include error monitoring?

Django can email ADMINS for server errors when DEBUG is false and can report some broken links to MANAGERS. Dedicated monitoring becomes useful when you need grouping, history, releases, alert control and user-impact context.

Should a Django health endpoint check the database?

A readiness endpoint may perform a small database check when the application cannot serve useful traffic without the database. Keep a separate lightweight liveness signal so a temporary dependency failure does not always trigger a process restart.

Should health checks expose exception details?

No. A public health response should reveal only the minimum status needed by the monitor. Keep exception messages, database details and infrastructure names in protected logs or monitoring tools.

How do I know whether a Django alert is useful?

A useful alert identifies the affected application and environment, explains the failed condition, links to diagnostic context and has a clear owner. Test the complete delivery path and remove alerts that repeatedly require no action.

Turn the checklist into one Django overview

FetchNode combines focused error monitoring, request health, uptime, releases and customer journeys for Django developers who do not need a full enterprise observability stack.