Python's dynamic nature is a feature, not a bug! Sometimes we want type safety too. Let's look at building "static islands" around Django's dynamic core. Type-safety where you need it, without sacrificing the flexibility of Python that you know and love.

Building applications to serve actual users is really hard! Traffic spike, data accumulates, queries becomes slow, response time suffer and you sre left completely baffled!

In this workshop we'll optimize real-life scenarios in a Django application using advanced indexing techniques in PostgreSQL. We will also identify and tackle concurrency issues and experiment with different approaches to prevent them, without bringing the system to a halt.

By the end of this workshop you'll learn how to prepare your Django application for the real life.

Ever thought about what happens when someone finds a security issue in Django? How do you disclose an issue responsibly? What happens after that? How does the Django team work on it? What happens until a security release is published? What comes afterward? And what impact have AI and LLMs on Django and its security?

ATLAS is a production-grade IT Service Management platform built with Django for the Greek Ministry of Migration and Asylum. Designed and deployed with zero external budget, it centralizes IT requests into a workflow-driven system with Single Sign-On, role-based access control, automation, SLA monitoring, and real-time analytics. The system is used daily across the Ministry and has resulted in 70% faster incident response initiation and 98% user satisfaction.

AI-assisted contributions are changing how open source work happens.
This talk looks at real maintainer experiences from projects like Django, Python, GNOME, and OCaml, focusing on review load, responsibility, and the governance questions that appear when AI replaces understanding instead of supporting it.

The existing implementation of Django Signals does not address fault tolerance in any way, which makes Signals unreliable for mission critical workflows! In this talk I present an alternative underlying implementation using the new tasks framework in Django 6 which makes Signals fault tolerant and reliable.

There are many ways to do "interesting" things with forms...

With HTMx it is possible to treat any HTML tag as a form, without using form tags. It becomes easy to alter just one field of a form: click on the field to swap out the presentation with a suitable input field, then submit that single field on pressing Enter.

What is not necessarily so easy is adapting the use of Django's forms so that they are used both for validation and rendering of that single field, and smuggling in the necessary context a form widget needs if one skips the <form>-tag and uses widget templates to render the inputs.

Incidentally it does become easy to have plugin-able forms...

This talk will briefly look at previous "interesting" (ab)uses of Django forms, followed by demonstrating some hands-on techniques and patterns for working with single fields, using a special made demonstration site and a production service that was converted in 2024-2025 from a SPA using REACT to an MPA using HTMx: Argus.

Django: https://docs.djangoproject.com/
HTMx: https://htmx.org
Live Argus demo: https://argus-demo.uninett.no/
Argus code: https://github.com/Uninett/Argus
Code for singlefield demo: https://github.com/Uninett/singlefieldform
Slides: https://github.com/Uninett/singlefieldform/tree/main/slides

The llms.txt format is an emerging standard to structure information for Large Language Models. It’s a desirable addition to the docs of Python packages.

Let’s review how to adopt it! We’ll discuss the fundamentals of the format and its benefits as a user of the docs, and as a maintainer. How to produce and consume those files across different tools (Sphinx, mkdocs, Django). How to optimize them for different LLMs with an eval suite. Tools and techniques you should be able to reuse through other engineering tasks with LLMs.

The question is simple: How do you scale Django beyond a single database? The answer isn't simple, but it is fun and interesting.

Database tables in PostgreSQL cause increasing performance and maintenance issues as they grow larger. We look at ways of managing those problems with partitioning, the choices available, and how to partition existing tables at Kraken scale with Django.

AI Agents have become increasingly good at generating code. Developers who know how to use agentic tools as they program can increase their productivity significantly. In this talk, Marlene will share how Django Developers can get the most out of coding agents in their development workflows. She'll walk through how she uses MCP (Model Context Protocol), Agent Skills and Instructions to create semi-autonomous agents that can complete multi-step tasks end-to-end. She'll also walk through best practices for validating the output of agents end to end with unit tests and Playwright. As part of this talk we'll also discuss the societal implications of AI on developers and how we can best prepare for the future thats both coming and already here.

A pipeline using Python, Django, and LLMs to extract, structure and publish 2,700 incidents, turning old typewritten documents into useful data.

Most Django developers have been there: something is slow, users are complaining, and the first instinct is to sprinkle print() statements or scroll through server logs hoping for a clue. Without proper observability, diagnosing performance bottlenecks in a Django application (or any application, for that matter) is guesswork.
Observability is the practice of understanding what is happening inside your application by looking at the signals it produces: traces, metrics, and logs. While the concept is well-established in infrastructure and DevOps circles, it remains under-explored in the day-to-day workflow of many Django developers. Yet Django's middleware architecture, ORM, and request/response cycle make it particularly well-suited for instrumentation.

In this talk, I will walk through how to add observability to a Django app using Pydantic Logfire. I'll cover the Four Golden Signals of observability (latency, traffic, errors, and saturation), explain why they matter for your Django app, and show how to expose them with minimal setup. Through a live demo, you will see how to use metrics dashboards in action to monitor your system. You'll also see how to leverage AI to query your logs and traces in natural language or with SQL.
Attendees will leave this talk with a practical, reproducible workflow for adding observability to their own Django projects, along with an understanding of which signals to monitor and why.

Prerequisites: Attendees should be comfortable with Django basics. No prior experience with observability tooling is required.
Outline breakdown:
* 0–3 min The problem: Why print() and log scrolling don’t scale.
* 3–7 min Observability 101 for Django developers: The Four Golden Signals (latency, traffic, errors, saturation) explained with Django-specific examples.
* 7–12 min Setting up Observability - Instrumenting observability in a Django project: logging handler, Django instrumentation, PostgreSQL instrumentation. Live demo: showing traces appearing in the Live view.
* 12–19 min Built-in dashboards and system metrics: Enabling system metrics. Walkthrough of System Metrics dashboard. Mapping charts to the Golden Signals (CPU → saturation, process count → traffic). Building custom error charts with SQL queries. Live demo.
* 19–23 min Putting it all together: How to think about what to monitor. Practical tips for setting thresholds and correlating signals across dashboards.
* 23–25 min Wrap-up: Summary, resources, and where to go next.
* 25-30 min: Q&A

I have hired several dozen people for numerous different roles, I have interviewed hundreds, and reviewed thousands of applications - and I see the avoidable mistakes that are made over and over again. In this workshop I will share the employer's perspective, to help participants do better in their quest for a new role.

Django's built-in access control system is very good for basic operations and Guardian is a natural extension to the object level. However, our customers wanted more: a group hierarchy, just-in-time privileged access, delegating permissions to other users, custom permissions. This talk tells the story of how an authentication company built a role-based authorization system for Django.

Django's built-in admin is powerful, but it's essentially a separate framework within Django and it's 20 years old.

Wouldn't it be nice to be able to work with an admin interface that works like the rest of Django, built on generic views, plugins, and view factories? This is the idea I explored: a proof-of-concept Django admin replacement, powered by pluggy and generic views, where CRUD operations are just actions, knowledge transfers both ways, and everything feels like Django.

Let's explore together the concepts and ideas behind it.

Deploying Django with background tasks usually means juggling Celery, Redis, and separate worker processes which often mean adding complexity and operational overhead.

What if you could run everything in a single process while keeping isolation and performance?

A facilitated Open Space workshop bringing the Django community together to collectively explore, debate and document the key themes, concerns and opportunities around Django and generative AI – from developer tools to ethics, policy and beyond.

What if your Django app cannot rely on servers at all? This talk shows how to package Django inside Electron for confidential, offline, compute-heavy workloads, based on Steel-IQ, an open-source steel-industry simulation tool. You will see a production architecture running across macOS, Windows, and Linux, plus practical lessons from building and running it.

Fetching some items from the database, creating a grouped list of those items with a bunch of calculations on related items... sounds super-easy in python. Alas, in my use case,it made me include a "please wait while we're generating the data" modal in the frontend.
That's when I remembered a dear friend saying “Whatever it is you have to do, Postgres can do it, and fast!” Enter the ORM and its deep bag of tricks- chained annotations, subqueries, window functions, conditionals-in-query, digging into JSONB-arrays, and all this with no raw SQL (almost).

What really makes Django's documentation so good? What's significant about the idea of a handbook? And why does software need to pay attention to the body?

We built a drop in replacement to many of the standard Django Fields to encrypt the data in our database columns with almost no overhead, and zero database migration.

Configure your models to automatically prefetch related objects when needed with model field fetch modes, new in Django 6.1. This talk will cover usage, tradeoffs, and what distinguishes the "fetch peers" mode from prefetch_related() and select_related().

CVs are marketing documents that have the primary goal to help Software Engineers get to a job interview. In this workshop we'll look at some general best practices, and provide feedback to each others CVs to increase our chances to land a new role.

When we say "API", most people think REST or GraphQL. But Django has plenty of other APIs; one of the most common and confusing is manage.py runserver, especially when a beginner comes to deploy their first project. This talk explores Django's deployment story through the lens of API design, introduces django-prodserver as a path forward, and asks: what would it take to make going to production as obvious as starting development?

We're all familiar with Django's atomic context for managing database transactions, but Django existed for several versions before it existed. How were transactions managed before 2013? How are transactions managed now? And how might they be managed in the future?

Explore how Django is applied to ESA's NewAthena project, where significant amounts of data are managed in a scientific context, illustrating how a web framework can be extended to enable a large-scale space mission.

Django Template Transpiler is a project to transpile Django templates into Javascript render functions, much like what Handlebars can do. It is intended to solve use-cases where small parts of your UI needs to be rendered both on the backend (because corresponding data already exists) or on the front-end (in result of user interaction) and issuing HTTP queries to perform SSR is inconvenient because of bad internet access.

Django's built-in admin is powerful, but it's essentially a separate framework within Django and it's 20 years old.

Wouldn't it be nice to be able to work with an admin interface that works like the rest of Django, built on generic views, plugins, and view factories? This is the idea behind Django-Admin-Deux: a proof-of-concept Django admin replacement where CRUD operations are just actions, knowledge transfers both ways, and everything feels like Django.

This workshop will explore the concepts behind Django-Admin-Deux in details and we will build together:
- an application that uses it
- a custom plugin

Every pip install is an act of trust. Attackers have exploited that trust - phishing maintainers, hijacking CI/CD pipelines, turning popular packages into malware. Learn how these attacks work and practical defenses for your projects.