Django is the perfect companion for AI work. Learn how to train your own ML model from scratch in a Jupyter notebook and then quickly deploy it with Django.

Unit tests are the front line of defense to keep your applications and projects bug-free and reliable. Make them strong and steady by working with Django to write your tests instead of despite Django. From decorators to mocks — to factories and assertions — we will armor you with tools, patterns, and strategies to make unit testing easy, efficient, and send your coverage to the moon!

The GeneratedField is a new field available in Django 5.0 whose value is computed entirely by the database based on the other fields in the model. In this talk, we will learn together how to use this field through various practical examples.

"Come for the language, stay for the community." This is a mantra of Python communities, including Django. It's clear how easy it is to forge a strong bond with people in our communities. But have you noticed when you solve one problem for the community, you're soon asked to help with two more problems? You might have even noticed that this phenomenon seems to never stop either. As long as you have time and energy, you're welcomed to do more and more for the community.

Our communities and our contributors need boundaries. Open source software governance is one way to help raise those boundaries. The presenters want to share with you their lessons learned from their time as open source contributors and community organizers in various organizations in the Django community. Leaving this talk you will understand why governance is important to think about from the start, how to define a basic governance structure and how to integrate it into an existing community. Our goal is to raise awareness around the need for clearer expectations so people feel more confident contributing and feel less guilty when they can't.

Many website redesigns are driven by frustration with an underlying content management system (CMS). Most often, it’s not the CMS itself but its implementation and governance around content and patterns. If we want Wagtail CMS, and thus Django, to flourish, we must make building a website enjoyable over the long term. This talk explores best practices for modeling content and design systems in Wagtail CMS, enabling developers to create content management experiences that editors love.

Coding boot camps promised to transform tech education, creating thousands of careers through immersive learning and community support. But their decline raises tough questions about equity and sustainability. As a graduate and instructor, I’ll unpack their rise and fall and the lessons we can take forward. Together, we’ll explore how the Django community can foster more inclusive and effective pathways into tech.

At MongoDB, we have several Django enthusiasts who have jumped at the idea of backing a long-term solution to combining MongoDB and Django. Having historically provided support for SQL-based open source frameworks like Entity Framework in .NET/C#, Doctrine in PHP, and many more, we are familiar with the territory. We're happy to say we've successfully created a MongoDB Backend Library for Django and want to share all that we've learned kitting out a new NoSQL backend for a traditionally SQL framework including how we believe we have influenced -- and will continue to influence -- changes in the core Django library.

While launch day is often anticipated as a satisfying completion to a project, the reality is often different. Real users in the production environment may test our code in unanticipated ways, leading to surprising bugs that need to be addressed, often under time pressure and with fewer debugging resources than we're used to having in our development environment. Come to our talk and learn how to enjoy debugging in production!

Recent improvements in Vue 3.5 offer a compelling new way to inject JavaScript interactivity into Django templates: Web Components. You can now encapsulate interactive behavior within Web Components, register them in your Django application with a single line of JavaScript, and use them in Django templates by custom tag name. You can even embed Django template content, including tags and context variables, directly inside these components.

No magic attribute names. No mounting elements by selector. No manual attribute datatype coercion. No more fighting the framework.

Using a Web Component in a Django template is as easy and intuitive as:

<my-product-card name="{{ product.name }}" rating="{{ product.rating }}">
  <a href="{{ product.url }}"><img src="{{ product.image }}"></a>
</my-product-card>

This talk shows you how to move beyond partial JavaScript sprinkles without resorting to full-blown single-page apps and REST APIs, and instead build interactive, maintainable components that drop straight into your Django templates with minimal friction.

Djangonaut Space is a mentorship program created to address the problem of sustainability for open source projects. It helps grow the community and bridge the gap between new contributors and long-time maintainers, ensuring the web framework and its eco-system continues to thrive and adapt to changing needs.

Discover how Python is shaping the future of our planet in this engaging talk. I’ll explore how Python is used to model climate change, monitor environmental shifts, and drive sustainability projects. See how this powerful language is enabling scientists and developers to turn data into actionable insights, helping to tackle some of the most pressing challenges facing our world today. Whether you’re a coder or a climate enthusiast, this session will show you how Python can make a real difference for the Earth.

What if building with Django wasn’t just about code, but about changing lives in places with limited internet, few resources, and no fully established tech industry?

In Namibia, that’s exactly what happened.

As a founding member of the Python community in Namibia and the founder of Django Namibia, I’ve spent the past 10 years helping grow a grassroots open-source community. With minimal infrastructure but maximum commitment, we introduced Python and Django to schools, rural areas, and aspiring developers, many of whom had never written a single line of code.

In this talk, I’ll share how we built a thriving, inclusive community from the ground up. I’ll reflect on milestones like launching Django Day Namibia for the first time, mentoring over 50 women, and engaging 60 students through Education Day at PyCon Namibia this year. I’ll also discuss real-world projects where we applied Django to areas like wildlife conservation, healthcare, and tourism, many of which I contributed to directly.

This isn’t just a story about technology. It’s a story of resilience, creativity, and the power of open source in even the most unexpected places. I was driven by a desire to give back to my country, the continent and empower individuals in underserved areas, believing that technology can open doors where there were none. If you’ve ever wondered whether your work, or your community, can make a difference, this talk is proof that it can.

When it comes to database performance tuning, most PostgreSQL practitioners focus on optimizing configuration parameters. Although some parameter tuning can indeed improve the database performance, we are usually talking about 10%, 20%, and in rare cases, up to 50% performance improvement. That might sound like impressive numbers, but individual query optimization routinely makes queries run several times faster, in some cases, ten or more times faster!

Sharing urls using QR code is a common use case nowadays.

You might have seen restaurants sharing links to their menu or loyalty programs using QR code. A conference speaker might have lots of links to share during their talk, and it's not always practical to share long links in their presentation slides. Using QR code would help, but QR code creation is a mysterious process.

There are various websites and services that lets you generate QR codes. However, these services sometimes aren't free, or they might serve ads on the website. What's even worse, sometimes these services would mask your url with a their own url shortener or domain. Users will hesitate to scan your QR code if it is not clear where it's taking them to.

Do we really need to use these services in order to accomplish simple thing like generating an image?

Let's reverse engineer these services and see how we can build our own using Python and Django.

Learn how to build your own version of QR code generator and URL forwarder service in this talk.

Have you ever been drinking a glass of wine and wondered how it was made? Creating an amazing bottle of wine is a fascinating process involving equal parts farming, art, science and a dash of luck. Every year during harvest season, winemaking teams scramble to harvest the best fruit, press it to juice, ferment it, and prepare it for aging. It can require teams of people and around the clock work during harvest. Even after harvest, it may still be years of blending and aging before the finished wine ends up in a bottle on the shelf of a store. It is a lot of coordination and effort, and winemakers need to be able to review all of the steps they have taken thus far in making the wine so that they can plan for the next steps. This is where software comes into play.

Event sourcing is a powerful architectural pattern where the state of an object is defined by the sequence of events that have occurred to it. In our system, events are tied directly to meaningful user actions: instead of generic updates like "wine updated," we record specific events like "volume transferred" or "blended with another lot." These events are stored in chronological order in what’s called an event stream.

A key tenet of event sourcing is that events are immutable. Once something has been documented as happening, then it always happened. Most commonly, to fix a mistake in the system, another event is recorded at the end of the event stream that registers the necessary correction, as opposed to altering the original event.

The idea of an immutable event stream didn't work for us at InnoVint, but everything else about event sourcing ticked all the boxes. So we set out to reimagine event sourcing to allow our users to alter the past, allowing the implications of the edit to flow through everything after it. In this talk, we'll work through how this mutable event system is implemented using the Django ORM and how our developers interact with the event stream to build complex user behaviors.

Outline

• Provide a high level introduction to the winemaking process and why it makes such an exciting domain for software development.

• Introduce event sourcing using domain driven design.

• Dig into why the winemaking process is difficult to model using standard, immutable event sourcing.

• Present the idea of "actions" as persisted and editable, user-defined commands representing complex real world behaviors.

• Show how these actions can be directly linked into an event stream to allow rewriting the history of the event stream.

• Demonstrate how a unit-of-work decorator and domain driven aggregates populate the event stream.

• Putting the pieces together, work through an example of how a user can interact with an example application to track, and correct, the steps in making their wine.

This talk is ideal for developers who are already comfortable with Django and are interested in ways to expand its capabilities.

You want to test against something as close to production as possible - but you don’t want to expose client data or company secrets during your development process. Let’s talk through the world of development environments for your Postgres database. From local options to using the cloud. We’ll also cover what’s available in terms of replications, copies, anonymizing data, and automation. Believe it or not, there’s some Postgres tricks that can make this easier for your team.

Working with a mature codebase is a bit like dealing with a teenager - things are mostly functional, occasionally unpredictable, and constantly reminding you of your past decisions. In this talk, I’ll share a collection of hard-earned lessons and useful patterns from maintaining and evolving a 15-year-old Django project. From keeping your legacy front end framework in sync with your shiny new tool, to taming complex APIs and tracking performance with precision, this is a tour through a handful of useful patterns picked up working with a stable codebase through the years.

Most of us protect our Django apps with static rules block a few things, set some rate limits, hope for the best. But attackers are getting smarter, and our defenses aren’t keeping up. In this talk, I want to show you a different approach: a way for your Django app to actually learn from real traffic and get better at protecting itself over time.

I’ll introduce you to AIWAF, a Django-native Web Application Firewall that trains itself by analyzing your web logs. It learns what normal behavior looks like and more importantly without needing constant manual rule updates. It can catch things like 404 floods, UUID tampering, honeypot field triggers, and suspicious burst attacks automatically.

Under the hood, AIWAF is powered by a lightweight machine learning model (Isolation Forest) combined with simple but powerful behavior statistics. No machine learning background is needed it integrates into Django just like any middleware or management command.

AIWAF is built for the small teams, the indie devs, the nonprofits for anyone who wants real-world, adaptive security without enterprise-level costs or complexity.

Content Management Systems are often considered the backbone of a business website that serves as the central hub for marketing and information about a business's products. As a developer, you are the gatekeeper and caretaker of the CMS and all who use it. It is not uncommon to see content staff finding the content management system difficult to navigate when starting out, or having to fight with the CMS to make it work. This talk will cover how to use Wagtail to take control of the CMS and customize it in a way that best suits your vision and your content writing staff's workflows.

Search is a core and high user impact feature in many Django apps. However, queryset filters and keyword search in Django apps often fails to meet user expectations for search relevance, speed, and personalization.

This talk introduces vector search — a powerful new paradigm that goes beyond keywords to search, recommend, and analyze your data. You’ll learn the basics of vector embeddings, how vector search works, and how to integrate vector databases into your Django models using the django-semantic-search package — with practical code examples.

We'll show a demo of product search/recommendations in a Django e-commerce app, then briefly explore other use cases like multi-modal search, content discovery, clustering, and retrieval-augmented generation (RAG). Finally, we’ll cover the trade-offs of vector search to help you decide when it’s the right tool for the job.

Unlock the power of debugging in Django! Learn how to leverage IDEs like PyCharm and VS Code to pause, inspect, and interact with your code. From breakpoints to call stacks, master debugging for faster, smarter development.

Our team at Energy Solutions spent a year building a robust data ingestion and query pipeline using OpenSearch to provide centralized data to a distributed suite of applications. Along the way, we learned to question and rethink a lot of our relational database assumptions and take fuzzy search customization and accuracy to the next level. Meanwhile, we implemented Pydantic wrappers around JSON responses so we could continue to handle responses like native Python objects (along with other benefits we’ll discuss). We addressed long-standing challenges, such as:

• Improving the performance of the per-row create/update/delete paradigm (in one case, leading to a ~9x faster data ingest + load!)
• Putting OpenSearch “aliases” to work to help track current vs archival data
• Improving search relevancy
• PII exposure reduction

In this presentation, we’ll walk through the decisions that led us to moving to an OpenSearch-based solution that works within a traditional Django framework, how we tackled advanced topics like token analysis, and how we put OpenSearch aliases to work. We’ll also cover some of the cost-benefit equations, summarize our next phase of work in the project, and include real-time demonstrations of some concepts.

Over the past year, we cut our site’s average server-response time in half - and learned a lot along the way. This talk walks through several performance case studies, complete with real numbers from production, surprising missteps, and practical insights into what actually made things faster (and what didn’t).

Participating in online open source communities can be a positive experience, but it isn't necessarily so for everyone. Stories abound of mistreatment of project maintainers and community contributors, including bullying, doxing, even acts of outright violence. But those negative experiences don't have to happen! Creating a safe and welcoming environment for open source development begins with you.

Django gives a Web programmer utilities, functional classes, and places to put things. Complex data pipelines could use the same kinds of structure. Data engineers deserve a good developer experience too - and many folks do both Web and data. The phaser open source library has abstractions for data pipelines, columns operations, phases and checkpoints, and many of its principles are applicable even without using phaser.

When you are acquiring data for multiple models in your db:
* Are your data transformations testable? Can they be remixed?
* Can you debug a pipeline that has already run?
* Is your code re-usable when you need to add a new data source or handle a different format?

By sharing what we’ve learned building data pipelines and building phaser, we hope to spread not only knowledge about this library, but also useful principles, abstractions and architecture to make data pipelines more readable, robust, maintainable and re-usable.

With Django 4.2's introduction of comments on columns and tables, your models can now serve as living documentation. This talk demonstrates how to combine unmanaged models with database comments to create self-documenting database interfaces that improve team collaboration and system understanding.

We often hear about using coding skills to create passion projects, but what does that journey really look like? In this talk, I’ll share how debates about NBA players in a group text thread evolved into ShotGeek—an open-source Django web application for tracking and comparing the statistics of current and retired NBA players. I’ll discuss the technical challenges, lessons from community contributions, and the ups and downs of managing an open-source project fueled by personal passion. This talk will highlight how shared interests can drive meaningful and joyful tech projects—and why yours could too.

Our team has been using Django as our web framework of choice for a decade. Over the same time, I have been on a personal journey of recovery, finding more about myself and trying to grow into the kind of person I want to be, with the help of two amazing communities. My Python/Django family and my recovery family have both been wonderfully supportive of my life journey.

In 1729, Jonathan Swift presented an elegant and well thought-out solution to the problem of homelessness and poverty plaguing Ireland. He argued that his solution would result in a much more productive and fulfilling society. While not many could digest the meat of his proposal, it was still effective in exposing a widening gap of social inequality and abuse.

Is it possible that Swift's proposal can be applied within our technosphere? Did he provide us with a recipe for success, or at least little nuggets of wisdom to chew on?

Many attending this conference may be keenly aware of the dichotomy between open source and big tech. There is a relationship that always seems to be at risk of imploding. Should we be encouraging new (and existing) engineers to participate in open source, in spite of this tenuous relationship? If this topic whets your appetite, you'll definitely want to come to see what's cooking.

Python 3.13 enabled experimental support for free threading, which disables the GIL, and allows multiple threads to execute in parallel without getting blocked by the GIL. This has huge promise and potential with Django for both performance and efficiency, because traditionally Django is run with gunicorn (or uvicorn in the asynchronous case), which will do a process per-worker. The ability to be able to use threads instead of processes and still have them execute in parallel would indeed be a considerable boost to performance and potentially memory efficiency as well, but there are a number of hurdles that will have to be overcome before this becomes a reality. This talk will explore those hurdles, highlight Django internals that may be impacted by free threading, and do a live demo of free threading performance and memory efficiency with Django.

Deployment has been a notorious sticking point in Django for a long time now. django-simple-deploy offers a simple, reliable way to carry out successful deployments to a variety of platforms, the first time you try. The plugin model makes it possible to collect our shared wisdom around deployment, and to support a growing number of hosting platforms as well. This talk will explore how django-simple-deploy works, what platforms it currently supports, and how you can contribute to its growing plugin ecosystem.

In 2014, I co-authored High Performance Django, a book that helped thousands of developers build faster, more reliable Django apps. Ten years later, I’m back to share what’s changed and what hasn’t.

This talk distills a decade of lessons from the front lines at Lincoln Loop, where we build and maintain Django sites handling hundreds of millions of requests per month. You’ll learn which performance strategies have stood the test of time, which ones we’ve outgrown, and what’s new in our current stack for keeping Django fast, stable, and scalable in 2025.