DjangoMaxxing: Serving Thousands of OTLP Requests per Second in One Process

Speaker: Paris Kasidiaris

We pushed Django to its limits.

We built a OpenTelemetry server with Django 6.1 and Python 3.14. It accepts OpenTelemetry traces and logs, including exception events, serving thousands of requests per second.

There is no Redis, external collector, thread pool or database server. Just Django, a single asyncio loop, SQLite, and refusal to add unnecessary complexity.

This talk explores what Django makes surprisingly easy, where it fights back, and how far a single event loop and SQLite writer can go. We’ll share benchmarks, design decisions and how a simple setup handles more than people give it credit for.

Abstract

Django is not the first framework people choose for a high-throughput observability backend. We did it anyway.

We built a production-grade OpenTelemetry Protocol (OTLP) server with Django 6.1 and Python 3.14. The server accepts OTLP traces and logs, including exceptions, processes them through Django’s ASGI request stack, and persists them to SQLite. The entire system runs as one process, one thread, one asyncio event loop, and one SQLite writer. There is no Redis, external collector, database server, thread pool, sharding, or distributed coordination.

The design is deliberately constrained. We add complexity only when absolutely needed. That constraint creates a useful way to study the actual costs of a Django request: protocol handling, request dispatch, validation, serialization, async boundaries, buffering, persistence, and backpressure. It also exposes where Django helps and where its defaults and lifecycle become limits under sustained ingestion.

In this talk, we will walk through the architecture, design decisions, benchmark methodology, throughput and latency results. We will examine SQLite’s role as the storage layer, and the failure modes that appear as load increases. We will also look at how far a single asyncio loop can go when the workload is designed around it, and the limits of the one-process model.

Django can handle large workloads and that the simplest architecture can remain surprisingly competitive.

About Paris

TBD