fidzu : Django

Will and Jeff are at PyCon US in Long Beach, California this week. Drop by the Django Software Foundation booth or the JetBrains booth and say hello.

News

Django Developers Survey 2026

The Django Software Foundation is once again partnering with JetBrains to run the 2026 Django Developers Survey 📊 Help us better understand how Django is being used around the world and guide future technical and community decisions.

DSF member of the month - Bhuvnesh Sharma

Bhuvnesh is a Django contributor since 2022 and a Google Summer of Code (GSoC) participant in 2023 for Django. He is now a mentor and an admin organizer for GSoC for the Django organization, as well as the founder of Django Events Foundation India (DEFI) and DjangoDay India conference.

Announcing the Google Summer of Code 2026 contributors for Django

Google Summer of Code 2026 contributors have been announced for Django, listing the developers who will be working on projects as part of the program. If you are following Django's next wave of community work, this is the roll-up of who's joining and what to watch for.

Releases

Python 3.14.5 is out!

Python 3.14.5 is now available, bringing the latest point release in the Python 3.14 line. If you maintain Django apps, use the update as your prompt to verify dependencies and run your test suite against 3.14.5 before rolling forward.

Updates to Django

Today, "Updates to Django" is presented by Johanan Oppong Amoateng from Djangonaut Space! 🚀

Last week we had 22 pull requests merged into Django by 13 different contributors - including 4 first-time contributors! Congratulations to Denny Biasiolli, Milad Zarour, MANAS MADESHIYA and Héctor Castillo for having their first commits merged into Django - welcome on board!

This week's Django highlights: 🦄

• Allowed max redirect URL length to be set on HttpResponseRedirect. (#36767)
• Added support for object-based form media stylesheet assets. (#37085)
• Deprecated SHA-1 default for salted_hmac() and base64_hmac() algorithm. (#37078)

Python Software Foundation

Python Software Foundation News: Announcing PSF Community Service Award Recipients!

Python Software Foundation has announced the recipients of its PSF Community Service Award. The update highlights people recognized for their contributions to the Python community.

Python Software Foundation News: Strategic Planning at the PSF

Python Software Foundation News covers the PSF's strategic planning efforts and the direction they are working toward. Expect a focus on how the foundation plans its priorities and activities moving forward.

Wagtail CMS News

Results of the 2026 Wagtail DX with AI survey

The 2026 Wagtail DX survey reports where teams are applying AI and what they want next from the platform. Use the findings to align your own Wagtail and AI experimentation with the issues practitioners are actually raising.

Our four contributors for Google Summer of Code 2026

Google Summer of Code 2026 is welcoming four contributors, highlighting the people behind the upcoming work. If you're tracking Django ecosystem activity, this is a quick way to see who's starting and what to watch for next.

Sponsored Link

Middleware, but for AI agents

Django middleware composes request handlers. Harnesses do the same for AI agents - Claude Code, Codex, Gemini in one coordinated system. Learn what a harness actually is, why it's a new primitive, and how to engineer one that holds in production. Apache 2.0, open source.

Articles

How to have a great first PyCon (updated for 2026)

Timeless advice from Trey Hunner on how to make the most out of PyCon US this week or any other technical conference.

Using Django Tasks in production · Better Simple

Production-ready Django task setups: what to change, what to watch, and how to keep background jobs reliable once you leave local dev. Useful guidance for deploying and operating task workers with fewer surprises.

Dealing with Dead Links (404s): 2026 Edition | Will Vincent

A practical guide to handling dead links in Django, focusing on what to do when a URL no longer exists and how to respond with clean, user-friendly 404 behavior. Expect guidance on keeping routing and error handling tidy as your site evolves.

Podcasts

Django Chat #203: Deploy on Day One - Calvin Hendryx-Parker

Calvin is the co-founder and CTO of the consultancy SixFeetUp. We discuss developer experience from day one, Kubernetes as a feature, real-world usage of AI and agentic tooling, typing in Python, the junior developer pipeline problem, and more. Also available in video format on YouTube.

Django Job Board

Founding Engineer at MyDataValue

Junior Software Developer (Apprentice) at UCS Assist

Technical Lead at UCS Assist

Web Developer at Crossway

PyPI Sustainability Engineer at Python Software Foundation

Projects

abu-rayhan-alif/djangoSecurityHunter

A security and performance inspector for Django & DRF. Features static analysis, config checks, N+1 query detection, and SARIF support for GitHub Code Scanning.

janraasch/dsd-vps-kamal

A Django Simple Deploy plugin for configuring & automating deployments of your Django project to any VPS using Kamal.

15 May 2026 2:00pm GMT

🔗 Links

• SixFeetUp Careers
• getscaf, copier, tilt
• A CTOs Guide to AI Coding Assistants
• kind, nix, spec-kit
• Figma make

📦 Projects

• django-mail-auth
• disposable-email-domains
• turnstile
• django-modern-rest

📚 Books

• London Review of Books
• Big Panda & Tiny Dragon by James Norbury
• Universal Principles of Typography by Elliot Jay Stocks

🎥 YouTube

• YouTube Channel: @djangochat

🤝 Sponsor

This episode is brought to you by Six Feet Up, the Python, Django, and AI experts who solve hard software problems. Whether it's scaling an application, deriving insights from data, or getting results from AI, Six Feet Up helps you move forward faster.

See what's possible at https://sixfeetup.com/.

13 May 2026 3:00pm GMT

Recently I have been experimenting with http streaming and realized how it can improve page performance. If you come from the PHP world, you might know the command flush(). It immediately sends to the visitor what has been echoed to the buffer, and doesn't wait for the full page to be rendered on the server side. That allows the browser to start rendering the website before the whole document is rendered on the server and transferred. On the other hand, the usual Django HttpResponse renders the whole HTML document on the server first, and only then sends it to the visitor. So the initial HTML document rendering is always the bottleneck for the full page load. Here comes StreamingHttpResponse, which can be used to mimic what flush() does in PHP.

HttpResponse vs. StreamingHttpResponse in Action

When using a normal HttpResponse, the HTML document is first rendered on the server side, then sent to the browser, then static files are downloaded in parallel if possible, and lastly rendering in the browser happens.

When you use StreamingHttpResponse, you can send the <head> and the content above the fold as the first part of the document, so that static files can be located and start downloading while the rest of the HTML document is being sent in parts. The first paint of the document would happen just after the CSS file is downloaded, and the rest of the HTML document would be drawn at a later point.

Generic HTML Streaming View

Here is a generic HTMLStreamingView that expects a list of template files, get_document_context_data() for the global context, and get_template_context_data() for the template-specific context:

from django.http.response import StreamingHttpResponse
from django.conf import settings
from django.template.loader import render_to_string
from django.views.generic.base import View


class HTMLStreamingView(View):
    # templates for different parts of the document
    template_names = []  
    extra_context = None

    def get(self, request, *args, **kwargs):
        # Capture the nonce before StreamingHttpResponse is returned. 
        # CSP middleware writes the nonce into the response header during
        # process_response, then replaces request.csp_nonce with 
        # an error-raising lazy object. generate() restores the plain value
        # so templates can access it during streaming.
        self._csp_nonce = (
            str(request.csp_nonce)
            if hasattr(request, "csp_nonce") 
            else None
        )
        context = self.get_document_context_data(**kwargs)
        return StreamingHttpResponse(
            self.generate(context), 
            content_type="text/html"
        )

    def generate(self, context):
        if self._csp_nonce is not None:
            self.request.csp_nonce = self._csp_nonce
        for template_name in self.template_names:
            template_context = {
                **context, 
                **self.get_template_context_data(template_name)
            }
            yield render_to_string(
                template_name, 
                template_context, 
                request=self.request
            )

    def get_document_context_data(self, **kwargs):
        kwargs.setdefault("view", self)
        if self.extra_context is not None:
            kwargs.update(self.extra_context)
        return kwargs

    def get_template_context_data(self, template_name, **kwargs):
        return {}

Use Case with the Strategic Prioritizer "1st things 1st"

The start page of the decision support system and strategic prioritizer 1st things 1st has been implemented as a multi-section landing page. The cookie consent widget only showed up after the whole page had rendered, resulting in a delay of a few seconds.

This is how I used HTMLStreamingView to reorganize the page into parts:

class StartPageView(HTMLStreamingView):
    template_names = [
        "startpage_index_top.html",
        "startpage/includes/description.html",
        "startpage/includes/tutorial.html",
        "startpage/includes/benefits.html",
        "startpage/includes/social_proof.html",
        "startpage/includes/testimonials.html",
        "startpage/includes/about_us.html",
        "startpage/includes/questions_and_answers.html",
        "startpage/includes/pricing.html",
        "startpage/includes/cause.html",
        "startpage/includes/call_to_action.html",
        "startpage/includes/footer.html",
        "startpage_index_bottom.html",
    ]

    def get_template_context_data(self, template_name, *args, **kwargs):
        if template_name == "startpage_index_top.html":
            return {
                "structured_data": settings.JSON_LD_STRUCTURED_DATA,
            }
        if template_name == "startpage/includes/social_proof.html":
            from django.contrib.auth import get_user_model

            User = get_user_model()
            return {
                "active_user_count": User.objects.filter(is_active=True).count(),
            }
        ...

        return super().get_template_context_data(template_name, **kwargs)

To transform a normal Django view into an HTTP streaming view, I cut the base.html template into two pieces:

1. everything before {% block content %} as base_top.html - the head and content above the fold.
2. everything after {% endblock content %} as base_bottom.html - the closing HTML tags and the footer.

For example, here's base_top.html:

<!DOCTYPE html>
{% load static %}
<html lang="en">
<head>
    <meta charset="utf-8" />
    <title>{% block title %}1st things 1st{% endblock %}</title>
    <meta name="viewport" content="width=device-width, initial-scale=1" />
    <link rel="stylesheet" href="{% static 'css/styles.css' %}" />
    {% block extra_head %}{% endblock %}
</head>
<body>
    {% block top_navigation %}
        <nav>
            <a href="/">Logo</a>
        </nav>
    {% endblock %}
    <main id="main_content">
    {% block content %}{% endblock %}
    {% include "startpage/includes/extra_js.html" %}

And here is base_bottom.html:

    {% block content %}{% endblock %}
    </main>
    <footer>
        ...
    </footer>
</body>
</html>    

I moved the JS from base_bottom.html to the body section of base_top.html, where it will start downloading immediately after the content above the fold is shown. I did that to reduce the delay for the cookie consent widget.

Then I prepared the templates for all parts of the start page:

1. startpage_index_top.html extends base_top.html
2. content templates provide the HTML directly without extending anything.
3. startpage_index_bottom.html extends base_bottom.html.

The Optimization Results

I used the Lighthouse plugin to measure performance for the start page on an emulated slow mobile network, before and after applying StreamingHttpResponse.

In the updated version, the content above the fold and the static files needed to render it are retrieved earlier. These include the static file requirements for the cookie consent widget, which can now be loaded from the initial part of the stream, so the widget appears sooner.

Final Words

HTTP streaming is a relatively simple technique that can make a noticeable difference in perceived page performance, particularly when it comes to metrics like First Byte and Contentful Paint. By sending the top of the document early, the browser can begin fetching static assets and rendering above-the-fold content while the server is still working on the rest of the page.

A faster Time To First Byte (TTFB) is also worth considering for LLM crawlers such as GPTBot or ClaudeBot. These bots often work with short timeouts, and if your server doesn't respond quickly enough, they may abandon the request before reading your content. HTTP streaming helps here too, since it gets the most important parts of your HTML out early - right at the top of the document where crawlers are most likely to see them.

That said, it does require splitting your templates into parts and thinking more carefully about which context data is needed where. If your page is lightweight and fast to render, the added complexity probably isn't worth it. The technique really shines on heavier pages that involve bigger database queries or external API calls - those are exactly the cases where server-side delay is most significant, and where streaming can therefore have the greatest impact.

It is also worth noting that HTTP streaming works with both WSGI and ASGI, so it fits into most standard Django deployment setups without requiring any major infrastructure changes.

Thanks to Famitsay Tamayo for the cover photo!

11 May 2026 5:00pm GMT

News

Announcing the Google Summer of Code 2026 contributors for Django

After receiving over 200 proposals from contributors across the world, four were selected for this year's GSOC batch.

Django security releases issued: 6.0.5 and 5.2.14

Three CVE-level security issues fixed. As ever, updating to the latest version of Django is a highly-recommended security practice.

Releases

Python 3.14.5 release candidate

Python 3.14.5 has a release candidate available, inviting testing before the final cut. Watch for any regressions or packaging issues while you validate your apps and dependencies against the RC.

Updates to Django

Today, "Updates to Django" is presented by Pradhvan from Djangonaut Space! 🚀

Last week we had 16 pull requests merged into Django by 15 different contributors - including 4 first-time contributors! Congratulations to Raoni Timo de Castro Cambiaghi, Anna Makarudze 🚀 , Fashad Ahmed, and Tilda Udufo for having their first commits merged into Django - welcome on board! 🥳

This week's Django highlights: 🦄

• FilePathField now has a set_choices() method that allows refreshing directory choices on a per-request basis by calling it in a form's __init__(). (#16429)
• Task and TaskResult instances can now be pickled by serializing functions as dotted import paths and reconstructing them during unpickling. (#36919)
• Deprecated double-dot variable lookups (..) in templates, which map to lookups of the empty string. (#35738)

The Django Software Foundation announced 4 accepted projects for this year's Google Summer of Code , congratulations to Praful Gulani, p-r-a-v-i-n, Keha Chandrakar, and Varun Kasyap Pentamaraju for having their proposals selected! 🎉

That's all for this week in Django development! 🐍🦄

Sponsored Link

Middleware, but for AI agents

Django middleware composes request handlers. Harnesses do the same for AI agents - Claude Code, Codex, Gemini in one coordinated system. Learn what a harness actually is, why it's a new primitive, and how to engineer one that holds in production. Apache 2.0, open source.

Wagtail CMS News

A customizable page explorer and other quality improvements in Wagtail 7.4

Wagtail 7.4 adds a customizable page explorer plus a set of quality improvements. If you rely on the admin's navigation and editor workflows, this release is about making those experiences more adaptable and smoother.

Independent security audit: findings and next steps

An independent security audit lays out its findings and the specific next steps to address them. If you maintain a Django app, use the recommendations to prioritize fixes, validate risk areas, and plan follow-up checks.

The carbon footprint of Wagtail AI

An interesting overview of Wagtail's AI footprint and more broadly links to carbon emissions by task during model inference (hint, hint image generation is expensive).

Articles

Using Django Tasks in production

The Djangonaut Space website has been using the Django Tasks framework and django-tasks-db in production successfully for about six months now. Some lessons learned from the integration in this article by Tim Schilling.

Thoughts from DjangoCon Europe

Carlton Gibson was a keynote speaker and shares highlights from the talks, events, and hallway chats that make the conference special.

Easily Stream LLM Responses with Django-Bolt and PydanticAI

Quickly setup an async streaming endpoint using django-bolt and PydanticAI in this tutorial from Caktus.

Python Unplugged on PyTV: Key Takeaways From Our Community Conference

A recap from March's PyTV digital conference, featuring talks from several Django figures including Mark Smith, PyLadies panel, Carlton Gibson on typing, Sarah Boyce on debunking Django myths, Sheena on Django development with Claude Code, and more.

Start Django Project

Get a clean start with a focused checklist for bootstrapping a Django project. Once the project skeleton is in place, you can build your apps, configure settings, and begin wiring URLs and models without rework later.

Core Dispatch #3

Core Dispatch #3 highlights what is landing in the Django core stream and what developers should pay attention to next. A quick roundup to keep your plans aligned with current core movement.

django-prodserver design updates

A quick rundown of recent design updates for the Django production server. Includes the key decisions behind the changes so you can track what's different in your deploy setup.

Me and Mentorship

A personal look at mentorship, focused on the practical habits and mindset shifts that shape both mentors and mentees. Useful reading if you want to think about how to support others in a way that actually sticks.

Png - I resolved my issue with virtual env and Docker.

A quick look at how to sort out Python virtual environment problems by leaning on Docker instead. The workflow focuses on getting dependencies and runtime isolation aligned so your Django setup stops fighting you.

Events

Asking the Key Questions: Q&A with the PyCon US 2026 keynote speakers: Rachell Calhoun and Tim Schilling

Rachell and Tim tease their upcoming talks on Djangonaut Space at PyCon US and highlight open source projects worth knowing about.

PyTexas 2026 Recap

A very deep-dive into the conference, with pictures, discussion of talks, new ideas, and more.

Podcasts

Django Chat #202: EuroPython 2026 - Mia Bajić

Mia is Vice Chair of the EuroPython society, a regular conference speaker, podcast host, and software engineer. We discuss what to expect at this year's event in Krakow, Poland in July this summer.

Projects

jsheffie/django-schematic

An interactive graph of your Django model structure. With related blog post.

archmonger/django-dbbackup

This Django application provides management commands to help backup and restore your project database and media files with various storages such as Amazon S3, Dropbox, local file storage, or any Django-supported storage.

08 May 2026 3:00pm GMT

(One of my summaries of the 2026 one-day PyGrunn conference in Groningen, NL).

When automating in a big company with many systems, you often end up with spaghetti: many systems connecting to a lot of the others... A common solution is to have a "bus architecture". Generic existing "enterprise service bus" solutions were clearly overkill, so he proposed an alternative solution.

He made a couple of assumptions/choices. All data is tabular data. He wanted to store a copy of data in a database. SQL views to access the data. So: multiple sources that he wanted to import in a central database (which would function as a sort of "read-only enterprise service bus"). And a generic sql/view-based way of accessing the data.

He initially focused on read-only data. And he started real simple. Just a bash script that ran regularly that scraped data from other systems and injected it in the database.

In the second version of the system, for every system he wrote a target/command in a Makefile. Every thing that needed to be scraped got its own table (called a "list" in his system"). Lists could be compared. The first killer app was a comparison between a telephone list and the list of employees so that differences could be consolidated.

For the third version, he started using more and more python. CSV file imports. Downloaders from REST APIs. All configurable so that he could use the same python script for many different sources.

He now had a simple sytem for which he could write views and exports.

• Publishing data on the intranet via the "jekyll" static site generator. For instance a "mug book" of all employees.
• And regularly exporting a list of names+emailaddresses in a format suitable for the multifunctional printer: to make it easy to select your email address when scanning on the printer.
• An export to a google spreadsheet that combined the holiday spreadsheet with the data on part-time days.

Security was handled with a role-based system.

Unrelated photo: the "lac de Kruth-Wildenstein" reservoir during a family holiday in France in 2006.

08 May 2026 4:00am GMT

(One of my summaries of the 2026 one-day PyGrunn conference in Groningen, NL).

Full title: layered architecture for readable, robust, and extensible apps.

Note: there's a related article on his own website :-)

Layered architecture resonates with people that make okay applications: their application do what they need to do. But once people start asking for changes, they get nervous. There might be huge functions. Or there might be no tests, "as it takes too much time to spin up the database". Brittle applications. Small changes are disproportionally expensive.

The goal of this talk: create apps that are readable, robust and extensible. By using the principle of separating everything in layers with a specific responsibility. It is not a one-size-fits-all solution: you have to adapt it to your situation.

The layers that he proposes:

• Interface: how the ouside world calls your application. An API or UI.
• Infrastructure and Repository: your contact with the outside world (like a database).
  • Infrastructure is tools. A http client. A mail sender.
  • Repository: persistence. SQL queries, caches. The aim is to decouple the rest of the system from db/cache/etc.
• Application: heart of your system, orchestrating the business logic. The Interface talks to the Application layer, the Application layer talks the infra/repo. And uses the Domain layer.
• Domain: constraints and definitions. He often uses Pydantic models here. It reflects the business meaning. It should be strict. Fail early. The "language" used should be a shared language between the engineers and the business people.

There are some rules, like the Interface only talks to the Application, not directly to the Infrastructure. And your code should be structured the same way. So a repo/ dir, an infra/ dir etc.

What are the benefits?

• It is more readable, you know where stuff is. This also helps with onboarding.
• It is more understandable, also to business people.
• Your app will be much more maintainable.
• Structure is clearer.
• Because you have more separation between concerns, validation is easier, so you tend to do more of it.
• Evolvable. You can build upon your existing code instead of modifying it.

How to get started?

• Start with separate directories. If you wonder where a function should go, it probably has too many responsibilities :-)
• Add tests.
• Start small.
• Focus on validation. Fail early.
• Isolate the business logic.
• Concentrate on the borders and separations.

Something to watch out for is making your models too big. You might have to split it into separate systems with their own responibility. A payment system, separate from the inventory system, for instance. You might want to create a small, focused shared domain system.

Unrelated photo: the "lac de Kruth-Wildenstein" reservoir during a family holiday in France in 2006.

08 May 2026 4:00am GMT

(One of my summaries of the 2026 one-day PyGrunn conference in Groningen, NL).

Years ago he listened to the "corecursive" podcast (recommended by Michiel), the one where Yann Collet got interviewed. He's the author of the LZ4 and zstandard (zstd) compression algorithm. In 2016 zstandard was released. In 2017 it was used in the linux kernel. Since 2020 it is one of the official formats in zipfiles. And in 2025 it got added to the Python standard library in version 3.14.

requests is one of the most popular Python libraries. httpx has a similar API, but it is better. A top 100 pypy packages. Main advantages: HTTP/2 support and async support.

He liked httpx a lot. And zstandard, too. But zstandard wasn't supported by httpx. All browsers support it, but not httpx. So he made a pull request in early 2024. It got merged! But there was no new release yet. The maintainer asked if he wanted to create a PR for the release. He did it and there was a new release. Hurray!

Months later, a bug surfaced. He created a bugfix, but that wasn't merged and wasn't merged and wasn't merged. And there was no new release. And then the httpx maintainer recently turned off all discussion on github. Earlier the maintainer had done the same to django restframework. And to mkdocs. All heavily-used packages! And in the "encode" github organisation/company that uses donations to fund open source development. Weird...

There are also performance issues in httpx, which especially is a problem for several AI libraries.

So... he started httpxyz, it bills itself as the maintained fork of httpx. More info about the reasons for the fork at https://tildeweb.nl/~michiel/httpxyz.html .

It contains most of the bugfixes that have been pending for a while. More maintainers. Performance is much better (they needed to fork httpcore into httpcorexyz, it is 4x faster). API compatible. You just have to change the import. They used a PIL/pillow trick to make sure that if you import httpxz, later httpx imports use httpxyz instead.

There turned out to be quite a lot of small performance errors in the old code.

An important performance tip: use client (or if you use requests, use request.Session()):

import httpxyz

c = httpxyz.Client()
c.get(...)
c.get(...)

instead of just:

import httpxyz

httpxyz.get(...)
httpxyz.get(...)

Using a client means httpxyz (or requests) can use http features to spead up your requests a lot. Automatic connection keepilive. No more TCP handschake for every individual request. And no TLS/https handshake. And if your server supports http/2, the improvement is even bigger. You do need to install httpxyz[http2] and specifiy httpxyz.Client(http2=True).

Nice: httpxyz also has a command line interface.

Something he only mentioned briefly: there oauth2 client_credentials support. You have to define a way to grab an oauth2 token, but the rest of the client work just uses the regular methods. Handy.

They're on https://codeberg.org/httpxyz/httpxyz instead of on github.

Unrelated photo: the "lac de Kruth-Wildenstein" reservoir during a family holiday in France in 2006.

08 May 2026 4:00am GMT

(One of my summaries of the 2026 one-day PyGrunn conference in Groningen, NL).

Full title: how to store and route your (physical) mail like a pro - personal edition.

How do you deal with your mail? Your physical mail? How do you store it? If the tax people want to have some information, can you find it, for instance?

Bart's motto is there must be a better way. So what is the pragmatic approach to better physical mail handling? A mail handling system that is flexible, automated, searchable and easy to use.

He discovered paperless-ngx, an open source document management system that allow you to store, organize and search your documents. Web interface, api, it can also read emails (via the "gotenburg" plugin). It can watch folders for new docs to process. It has features for structuring, self-improving (without AI). Tags. And you can have workflows.

Nice. Documents can go to Paperless. But he still has his bookkeeping system (he has his own company). And the bookkeeper wants emails with documents that are in Paperless. Can he improve this? For instance for receipts. He didn't want to scan all of them to PDF. And regular phone cameras don't produce PDFs.

He started using "dropbox camera". It works great for scanning receipts and documents. It recognizes corners and pages and enhances the contrast. It produces PDFs and uploads them to dropbox. (You must accept the fact that it ends up in the cloud: he build all this pre-Trump...)

He has a Synology NAS at home. That has a CloudSync app that you can use to sync the dropbox folder to the NAS.

He wanted to make some python glue gode. Ability to send to multiple destinations. Process folders for new files. Moving files to a "done" folder. Python looks at the various folders: he configured a specific custom "processor" per folder. So a move-to-paperless processor, for instance. And a processor that emails the scanned receipts directly to the bookkeeper.

Lots of it is automated. Just drop a PDF in a folder and the system takes care of it. Once in a while he checks Paperless and categorizes/stores what's left in the inbox.

It was a personal project, so he used it to experiment with Dataclass and Protocol. Don't forget to learn when you create/automate something for yourself.

He finds it awesome that something this easy saves him hours! What can you automate in your life?

Unrelated photo: the "lac de Kruth-Wildenstein" reservoir during a family holiday in France in 2006.

08 May 2026 4:00am GMT

(One of my summaries of the 2026 one-day PyGrunn conference in Groningen, NL).

His parents owned a record store in some Dutch town. First records, then CDs. A social shop where you would gather to listen to CDs to determine whether to buy them. His father's brother actually started the oldest record store in Amsterdam, Concerto. It still exists.

Then the world changed. Napster, CD-burners. Illegal downloading. (He himself was one of them). His parents stopped selling music in 2008. He himself got into engineering. He ended up in South Africa, doing workflow orchesration for radio telescopes. There he introduced Docker and containers. He gave a talk at Pygrunn about it in 2016.

While he was in the South African desert, in Sweden someone started the Spotify company. He actually had used a library ("luigi") made by Spotify in his telescope work.

He tried to get a job at Spotify and succeeded. So the kid who grew up in a record store now works at the company that reinvented how people listen to music.

It all started for Spotify with Java (jboss 5). They hated it. It was replaced with Python: the reason was that nobody hated it. 80% of the code became python. A lot was async: they used "twisted" in the beginning, later gevent and greenlets.

But the Python GIL (global interpreter lock) made multi-core impossible. So you needed to use multiple processes, each with their own overhead. They also didn't like the lack of type safety: they have 100+ services. Some of those problems are partially solved now, but at the time the switched back to Java. Partially it was cultural: they could hire quite some Oracle employees that knew Java.

Python was still used a lot, just not for the core services. Nowadays, Python is used a lot for machine learning. They have 950 Python services, 470 libraries. 180000 Python files in 7500 repositories. 322x FastApi, 272x Streamlit repositories. And still lots of luigi. Luigi is the framework that inspired airflow: it has lots of starts on github, the most of all their open source repositories.

They now also started pedalboard, a nice Pythonic way of modifying audio (it is a wrapper around a c++ library). Also nice: https://backstage.spotify.com/ , a backend/portal for collecting all the developer-related data. Workflow statuses and so. (The backend is open source, the dashboard not).

At Spotify, the programmers are really encouraged to use agentic programming. He hasn't touched his editor in the last six months! It really changed his life. Initially he was a bit depressed: can someone who's less talented but with the same amount of tokens really do the same as me? But it is really a next level and he gets amazing productivity out of it. Having unlimited tokens helps.

It changes open source. Forking used to be a declaration of war. Nowadays it is a sign of popularity. You can fork something and have AI keep it up to date with minimal engineer effort. When the cost of maintaining your own fork approaches zero, what does that do with the economics of open source? Is cooperation still a thing? What is the goal/effect of open sourcing? Or is it only a way for AIs to find security bugs in your software?

His parents ran a record store for 42 years. Then technology disrupted the music industry. They had to reinvent themselves. It was scary and sad, but they adapted. Now the same force is disrupting our industry. Where will it go?

Unrelated photo: the "lac de Kruth-Wildenstein" reservoir during a family holiday in France in 2006.

08 May 2026 4:00am GMT

(One of my summaries of the 2026 one-day PyGrunn conference in Groningen, NL).

Subtitle: a real-world journey from chaos to confidence using Pydantic and Pytest.

Idealy, you'd have perfect json files with a fixed format and rigorous validation and ideally generated. But in a customer project, the other programmers weren't too happy about it. They had massive JSON files, partially manually crafted. Some where just one single line and others were vertically aligned. And perhaps someone depended on the specific format for some "sed" or "awk" hacking... So whatever happens: it works, don't touch it.

The freedom trap. No schema means no contract. No contract means no trust. Fields accumulate, nobody removes them: "someone might be using it". Multi-team challenges: not everyone has the same skillset.

He wanted a different future: a trusted future. Validated and tested and formatted.

Pydantic is a python library for data validation using Python type annotations. You can define a data model with type hints. it will automatically validate and parse data according to those models:

from ipaddress import IPv4Address
from pydantic import BaseModel

class Server(BaseModel):
    hostname: str
    ip: IPv4Address
    ...

Make sure to look at pydantic-extra-types, they have lots of handy types like "two-character country code".

There's AfterValidator, you can use it to add a second validator to a field. So first the str type to validate it is a string, then afterwards some ip address validator or so.

Understanding the data is important. Split it up in smaller pieces and try to understand/model/validate those. Especially in a corporate setting, splitting up the problem is handy: you have some small success you can mention at the standup :-)

Do it iteratively. One piece at a time. If you find a problem, create a ticket for it. It might not get fixed, but at least you end up with a list you can slowly tackle with the rest of the organisation.

A good tip: if you discover an error in the data, provide a good, clear error message that your colleague can understand.

When you export the data, use model_dump(exclude_optional=True) to exclude all the optional fields instead of having it as my_field: None.

Bonus: you can call YourModel.model_json_schema() to generate a JSON schema for the Pydantic model. You can then use the JSON schema in vscode when you manually edit your JSON.

Pydantic is great at validating individual fields and structures. But not at validating things that span the entire document, like making sure that all hostnames are unique. He used Pytest for it: he wrote such validation checks as pytest functions!. You can even use Pytest test parametrization to run the same test on multiple directories.

Unrelated photo: the "lac de Kruth-Wildenstein" reservoir during a family holiday in France in 2006.

08 May 2026 4:00am GMT

While at DjangoCon Europe in Athens I had a fair few conversations about prodserver and spent a lot of time thinking about it because that was the thrust of my talk as well or the artifact of my talk mainly around the API of the command itself. I especially got to chat with Jake Howard of Django Tasks fame and asked him for his consideration about what his plans are for what a worker command might look like in Django core, which in turn, then impacts some of my thinking on Django prod server.

I have been documenting my thoughts and playing around with the API in a few different branches, but currently I have landed on these changes which will land at some point in the near future into django-prodserver:

• First up is renaming the command from prodserver to just server. This is a mirror to Jake's desire for just a single worker command that covers both development and production.
• Following on from this is adding development backends for runserver, runserver_plus and daphne. These aren't just calling them, but I am reimplementing them as full developing them from scratch as backends. I will also likely depreacate devserver with this change
• Finally I am then going to add a worker command to the package.

The design is then two commands, server for web processes, worker for background workers. The open question to me is how the settings for these commands is defined. Do I have a single settings or do I split it into two (or more)?

The final bit of architectural work that I want to do is to split the package into multiple packages. The first package will just have the core commands and a single developement backend. Then there would be other packages to contain the other production & development backends. The goal here is to break out and demonstrate what is most likely to be merged into core (if that ever happens), while keeping what ought to stay separate in other packages (ideally the backends would be merged into their respective servers at some point).

After this there is still addressing the existing issues others have raised on the repository, such as sane defaults, correctly handling arguments passing and the help text, ensuring we are using system checks and more.

If you have opinions on the above, please let me know! Comment on the relevant issues and perhaps even open a PR or just comment on this post. Thanks!

07 May 2026 5:00am GMT

Hi there.. it's been a while as usual… 😄

Today I would like to talk about mentoring. It's been a constant in my life. I have been on both sides: mentee and mentor. I can tell you that you learn so much from this exchange.

Being a mentee is a way to learn from an expert or just people who know more than yourself. Those people you truly admire for their work. The mentees don't even always tell how much they admire their mentors.

On the reverse, being a mentor is a good way to learn how to share your knowledge the best way. You watch the person you're mentoring grow and make their own decisions, without ever having to ask you for advice in the end, because you've given them the tools to find the answers on their own. One day, perhaps, they'll take the time to thank you, because without even realizing it, you've changed their life.

It's crazy, isn't it? I love mentoring because it's a special and unique exchange: you feel close to the other person, because when you're a mentor, you see a younger version of yourself in your mentee, and the mentee sees you as what they might one day become. I'm sure many people don't see mentoring exactly the way I do, but it's an extremely rewarding experience.

Mentoring is a great way to learn, whether you're the mentee or the mentor. Yes, mentors learn from the experience as well. How can you make sure your mentee has understood what you meant? How can you clearly explain something that seems obvious to you to the person sitting across from you? The mentee's questions help us discover aspects we had never considered before. There is so much to learn!

06 May 2026 9:00pm GMT

🔗 Links

• EuroPython 2026 website
• Mia's personal website and podcast, Behind the Commit
• A Year on the EuroPython Society Board by Mia
• EuroPython 2025 in Prague Recap by Will
• Mia on LinkedIn, Instagram, BlueSky
• Behind the Commit on YouTube

📚 Books

• Humble Pi: When Math Goes Wrong in the Real World by Matt Parker
• The Design of Everyday Things by Donald Norman
• Hands on Rust by Herbert Wolverson

🎥 YouTube

• YouTube Channel: @djangochat

🤝 Sponsor

This episode is brought to you by Six Feet Up, the Python, Django, and AI experts who solve hard software problems. Whether it's scaling an application, deriving insights from data, or getting results from AI, Six Feet Up helps you move forward faster.

See what's possible at https://sixfeetup.com/.

06 May 2026 3:00pm GMT

News

PyCharm Campaign Now Includes RENEWALS!

Past or current PyCharm Pro users can now take part in the PyCharm campaign! Add 12 months to your current PyCharm Pro subscription. The same deal applies to past, current, or first time users. Get PyCharm Pro 30% off and 100% goes directly to the DSF! Until May 3rd.

Adopt Annual Release Cycle (DEP 20)

A new DEP from Carlton Gibson proposing that Django move to an annual release cycle. There is a lengthy discussion on the GitHub ticket

What's new in pip 26.1 - lockfiles and dependency cooldowns!

A detailed post of new features from Richard Si, the current maintainer, including pylock files, dependency cooldowns, security fixes, and more.

Django Software Foundation

It's time to redesign djangoproject.com

A redesign of the djangoproject.com website is in progress. This post from the Django blog is an update on the project's process: the plan, who's doing the work, and how you can help.

Updates to Django

Today, "Updates to Django" is presented by Hwayoung from Djangonaut Space! 🚀

Last week we had 14 pull requests merged into Django by 13 different contributors - including a first-time contributor! Congratulations to Dinesh Thumma for having their first commits merged into Django - welcome on board!

All release note-related changes this week came from Djangonaut Space. 🚀

• Added ModelAdmin.delete_confirmation_max_display option to truncate the list of related objects on the delete confirmation page in django/contrib/admin/options.py, added in Django 6.1 (#10109).
• Fixed the inaccessible "---------" blank choice label in form <select> controls by replacing it with "- Select an option -" via a new BLANK_CHOICE_LABEL setting in django/conf/global_settings.py, added in Django 6.1, and deprecated BLANK_CHOICE_DASH (#35879).

Sponsored Link

Articles

Running from Django's main development branch in production

Carlton Gibson makes the case for running Django off of Django's main development branch rather than waiting for security and feature releases.

Before GitHub

Armin Ronacher, of Flask and other open-source Python fame, looks wistfully at GitHub's decline and points out that Open Source did not always work this way.

Leaving GitHub as a Social Network

David Guillot points out the many red lines that Microsoft has recently crossed and debates other alternatives.

pgBackRest is dead. Now what?

One of several posts on the longtime sole maintainer of pgBackRest stepping away. This is a fundamental tool for PostgreSQL and a general failure in the open source ecosystem. Additional posts by Jan, Christophe, Stefanie, and Jay.

Django Fellows Update

Fellow Report - Natalia

Another busy week triaging six tickets, reviewing six more, security reports, meetings, and discussions around the recent DEP 20.

Fellow Report - Sarah

Finished up Navigator duties for Djangonauts, managed tickets and security work, and weighing in on anew-features suggestion for Django Admin actions configurable as buttons.

Fellow Report - Jacob

A four day week after returning from DjangoCon yielded some wins like merging @annalauraw's work on improved blank choice labels in forms and @rodbv's work on truncating huge deletion confirmation pages in the admin.

Podcasts

Django Chat #201: DjangoCon Europe Recap + Other News - Jeff Triplett

Jeff is President of the Django Software Foundation and a partner at REVSYS. We discuss the recently held DjangoCon Europe conference, existing Django news, and then share notes on current AI-powered workflows. Also available in video format on YouTube.

Events

DjangoCon US Sponsorship Opportunities

DjangoCon US is August 24-28 this year in Chicago. There are still sponsorship opportunities available (hint, hint) for any companies that want to participate.

EuroPython 2026 tickets now available

This year's conference is in Krakow, Poland from July 13-19, covering two days of tutorials, three days of talks, and two days of sprints.

Django Day Copenhagen Tickets Available

This event is October 2nd and early bird tickets are now available. Note that the event can sell out due to the size of the venue.

PyCon US 2026 - How to Convince Your Boss

PyCon US is fast approaching. If you and your colleagues want to attend, we have a short template to help you discuss the conference at work.

Django London Meetup

Two talks at this event May 7th at Kraken Tech: a talk by Paolo Melchiorre on Django's GeneratedField and Django in the Lab by Andy Woods.

Projects

jsheffie/django-schematic

An interactive graph of your Django model structure. With related blog post.

The Fixi Project

From the creator of HTMX, a collection of five small web libraries based on other libraries they work on. See the related website for more information.

01 May 2026 3:00pm GMT

News

PyCharm Campaign Now Includes RENEWALS!

Past or current PyCharm Pro users can now take part in the PyCharm campaign! Add 12 months to your current PyCharm Pro subscription. The same deal applies to past, current, or first time users. Get PyCharm Pro 30% off and 100% goes directly to the DSF! Until May 3rd.

Adopt Annual Release Cycle (DEP 20)

A new DEP from Carlton Gibson proposing that Django move to an annual release cycle. There is a lengthy discussion on the GitHub ticket

What's new in pip 26.1 - lockfiles and dependency cooldowns!

A detailed post of new features from Richard Si, the current maintainer, including pylock files, dependency cooldowns, security fixes, and more.

Django Software Foundation

It's time to redesign djangoproject.com

A redesign of the djangoproject.com website is in progress. This post from the Django blog is an update on the project's process: the plan, who's doing the work, and how you can help.

Updates to Django

Today, "Updates to Django" is presented by Hwayoung from Djangonaut Space! 🚀

Last week we had 14 pull requests merged into Django by 13 different contributors - including a first-time contributor! Congratulations to Dinesh Thumma for having their first commits merged into Django - welcome on board!

All release note-related changes this week came from Djangonaut Space. 🚀

• Added ModelAdmin.delete_confirmation_max_display option to truncate the list of related objects on the delete confirmation page in django/contrib/admin/options.py, added in Django 6.1 (#10109).
• Fixed the inaccessible "---------" blank choice label in form <select> controls by replacing it with "- Select an option -" via a new BLANK_CHOICE_LABEL setting in django/conf/global_settings.py, added in Django 6.1, and deprecated BLANK_CHOICE_DASH (#35879).

Sponsored Link

Articles

Running from Django's main development branch in production

Carlton Gibson makes the case for running Django off of Django's main development branch rather than waiting for security and feature releases.

Before GitHub

Armin Ronacher, of Flask and other open-source Python fame, looks wistfully at GitHub's decline and points out that Open Source did not always work this way.

Leaving GitHub as a Social Network

David Guillot points out the many red lines that Microsoft has recently crossed and debates other alternatives.

pgBackRest is dead. Now what?

One of several posts on the longtime sole maintainer of pgBackRest stepping away. This is a fundamental tool for PostgreSQL and a general failure in the open source ecosystem. Additional posts by Jan, Christophe, Stefanie, and Jay.

Django Fellows Update

Fellow Report - Natalia

Another busy week triaging six tickets, reviewing six more, security reports, meetings, and discussions around the recent DEP 20.

Fellow Report - Sarah

Finished up Navigator duties for Djangonauts, managed tickets and security work, and weighing in on anew-features suggestion for Django Admin actions configurable as buttons.

Fellow Report - Jacob

A four day week after returning from DjangoCon yielded some wins like merging @annalauraw's work on improved blank choice labels in forms and @rodbv's work on truncating huge deletion confirmation pages in the admin.

Podcasts

Django Chat #201: DjangoCon Europe Recap + Other News - Jeff Triplett

Jeff is President of the Django Software Foundation and a partner at REVSYS. We discuss the recently held DjangoCon Europe conference, existing Django news, and then share notes on current AI-powered workflows. Also available in video format on YouTube.

Events

DjangoCon US Sponsorship Opportunities

DjangoCon US is August 24-28 this year in Chicago. There are still sponsorship opportunities available (hint, hint) for any companies that want to participate.

EuroPython 2026 tickets now available

This year's conference is in Krakow, Poland from July 13-19, covering two days of tutorials, three days of talks, and two days of sprints.

Django Day Copenhagen Tickets Available

This event is October 2nd and early bird tickets are now available. Note that the event can sell out due to the size of the venue.

PyCon US 2026 - How to Convince Your Boss

PyCon US is fast approaching. If you and your colleagues want to attend, we have a short template to help you discuss the conference at work.

Django London Meetup

Two talks at this event May 7th at Kraken Tech: a talk by Paolo Melchiorre on Django's GeneratedField and Django in the Lab by Andy Woods.

Projects

jsheffie/django-schematic

An interactive graph of your Django model structure. With related blog post.

The Fixi Project

From the creator of HTMX, a collection of five small web libraries based on other libraries they work on. See the related website for more information.

01 May 2026 3:00pm GMT

This week is a short detour from the normal technical topics I cover around Django, so feel free to skip if this isn't your thing!

Two big items this week, first up is that we launched Hamilton Rock this week! The next few months we will doing a private beta with select customers to test the system is working and get feeback about what's missing and needs more work. This is essential to us get some funding and finding where we are in product market fit!

Next up is that I will be mentoring Praful Gulani through Google Summer of Code this year on adding Experimental APIs to Django. I'm excited and nervous about this as it could have a fairly large impact on Django's trajectory, assuming we crack it and get the shape of this process and API correct. I am also hopeful to secure a new client in the next couple weeks which will address my immediate cashflow issues in the business.

In other news I'm working on a number of side projects. First up is Django Bureau and allpacked.co.uk. This is an experiment in getting AI agents to run an e-commerce store in an autonomous manner without much of my input, or at least that's the immediate goal. This will also have the side benefit of giving me greater understanding of our customers for Hamilton Rock.

Comfort Monitor Live has some updates coming in the pipeline which have developed much quicker thanks to Claude Code. Again with Claude I hope to do some concrete marketing in the near future, which will hopefully result in some revenue.

After the conversations and talk and DjangoCon Europe I have some renewed energy to put into django-prodserver, mainly around improving the API and shifting the development forward to a stable state.

Finally I have also forked a project from my church which is a Django backend for a virtual prayer/praise wall. I'm developing it into a more generic project that could suit more online communities, adding a few new feature ideas I have and perhaps exploring the idea of it being federated.

I do have other projects in the works, but they are lower down the list of priorites so the above need to get to a satisfactory place before I move on... or at least that's the idea, I was getting overwhelmed with the number of ideas/projects in my head so hopefully this is more managable!

I'm also wanting to blog about my adventures with neapolitan and pushing Django templates in new ways (again this required time I don't have much of!)

01 May 2026 5:00am GMT