&#32; submitted by &#32; <a href="https://www.reddit.com/user/Lazy_Equipment6485"> /u/Lazy_Equipment6485 </a> <a href="https://www.bhusalmanish.com.np/blog/posts/france-django-lasuite.html">[link]</a> &#32; <a href="https://www.reddit.com/r/django/comments/1qthpz0/france_is_building_its_own_google_workspace_with/">[comments]</a>

submitted by    /u/Lazy_Equipment6485  
 [link]   [comments]

France Is Building Its Own Google Workspace - With Django

<div class="md">R/django appears to be the largest community for a backend framework on Reddit and yet a significant amount of posters keep claiming Django is dying. How do you square that circle? </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/Boring-Tadpole-1021"> /u/Boring-Tadpole-1021 </a> <a href="https://www.reddit.com/r/django/comments/1qsu7ge/i_see_so_many_claims_that_django_is_dying_it/">[link]</a> &#32; <a href="https://www.reddit.com/r/django/comments/1qsu7ge/i_see_so_many_claims_that_django_is_dying_it/">[comments]</a>

R/django appears to be the largest community for a backend framework on Reddit and yet a significant amount of posters keep claiming Django is dying. How do you square that circle?
    submitted by    /u/Boring-Tadpole-1021  
 [link]   [comments]

I see so many claims that Django is dying, it seems to be thriving

<div class="md">Hi everyone I’ve been working on my own side project with Django called seenode to improve my knowledge beyond tutorials and small projects. With my growing project, I’ve started to think more about long-term maintainability rather than “just making it work.” Some questions I’ve been asking myself, and I’d appreciate your feedback on: <ul> <li>How do you determine when to start moving your business logic out of views and into services or domain layers?</li> <li>How do you usually structure your apps in medium-sized projects with many small apps versus fewer apps with broader scopes?</li> <li>What are some good practices in Django projects that scale well, and which ones don’t?</li> <li>What are some common architectural mistakes you see in medium-sized or larger projects with growing codebases?</li> </ul> I’m not looking to over-engineer my projects or anything like this. I’m simply trying to improve my instincts for good Django architecture. What are some decisions you’ve made early on in your projects with Django, that have helped you most in terms of maintainability with larger projects? </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/Away_Parsnip6783"> /u/Away_Parsnip6783 </a> <a href="https://www.reddit.com/r/django/comments/1qupslg/how_do_you_structure_your_growing_apps_for/">[link]</a> &#32; <a href="https://www.reddit.com/r/django/comments/1qupslg/how_do_you_structure_your_growing_apps_for/">[comments]</a>

Hi everyone 
 I’ve been working on my own side project with Django called seenode to improve my knowledge beyond tutorials and small projects. With my growing project, I’ve started to think more about long-term maintainability rather than “just making it work.”
 Some questions I’ve been asking myself, and I’d appreciate your feedback on:
  
How do you determine when to start moving your business logic out of views and into services or domain layers?
 How do you usually structure your apps in medium-sized projects with many small apps versus fewer apps with broader scopes?
 What are some good practices in Django projects that scale well, and which ones don’t?
 What are some common architectural mistakes you see in medium-sized or larger projects with growing codebases?
  
I’m not looking to over-engineer my projects or anything like this. I’m simply trying to improve my instincts for good Django architecture.
 What are some decisions you’ve made early on in your projects with Django, that have helped you most in terms of maintainability with larger projects?
    submitted by    /u/Away_Parsnip6783  
 [link]   [comments]

How do you structure your growing apps for long-term maintainability in your Django projects?

&#32; submitted by &#32; <a href="https://www.reddit.com/user/sgtunix"> /u/sgtunix </a> <a href="https://medium.com/@tk512/django-scales-stop-blaming-the-framework-part-1-of-3-a2b5b0ff811f">[link]</a> &#32; <a href="https://www.reddit.com/r/django/comments/1qrg9y5/django_scales_stop_blaming_the_framework_part_1/">[comments]</a>

submitted by    /u/sgtunix  
 [link]   [comments]

Django scales. Stop blaming the framework (part 1 of 3)

<div class="md">hi everyone Just sharing something I think this sub might appreciate. We built TypeQuicker where you can practice typing with content that relevant to you - whether it&#39;s Python snippets, cli tools, etc. We support almost every major coding language, some common cli tools, etc. If you&#39;re ever used a typing app, it&#39;s usually some &quot;a quick brown fox...&quot; or just random words. This felt a bit silly practice/learning typing with content like that - plus being a dev (and knowing how much modern browsers are capable) I felt that most sites were lacking in stats so we&#39;ve built a very detailed/robust typing stats overview system. anyway check it out if you&#39;re interested - cheers Edit: adding link - <a href="http://typequicker.com">TypeQuicker</a> </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/nerf_caffeine"> /u/nerf_caffeine </a> <a href="https://i.redd.it/ebyesbiv2lhg1.gif">[link]</a> &#32; <a href="https://www.reddit.com/r/django/comments/1qw8g2d/typing_practice_but_its_real_python_code_snippets/">[comments]</a>

hi everyone
 Just sharing something I think this sub might appreciate.
 We built TypeQuicker where you can practice typing with content that relevant to you - whether it's Python snippets, cli tools, etc.
 We support almost every major coding language, some common cli tools, etc.
 If you're ever used a typing app, it's usually some "a quick brown fox..." or just random words. This felt a bit silly practice/learning typing with content like that - plus being a dev (and knowing how much modern browsers are capable) I felt that most sites were lacking in stats so we've built a very detailed/robust typing stats overview system.
 anyway check it out if you're interested - cheers
 Edit: adding link - TypeQuicker
    submitted by    /u/nerf_caffeine  
 [link]   [comments]

Typing practice - but it's real Python code snippets

<div class="md">Explanation This visualizations work by assigning every file a dot. <ul> <li>Green = Low Complexity</li> <li>Red = High Complexity</li> </ul> Complexity is defined as Cyclomatic complexity (Mc. Cabe). The first image is Fast APIs dependency graph. Very structured and modularized. Very few Complex files and lower rates of connection between files. Most of the files are tests and tutorials. The second image shows Djangos graph: Much more interconnected and less modularized. More high complexity files but again most of the codebase is related to testing. Hope you found the comparison as interesting as I did! Edit: Django is a Batteries included framework with pre build auth and many other features whilst FastAPI takes a more lightweight approach. </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/swupel_"> /u/swupel_ </a> <a href="https://ast-visualizer.com/app">[link]</a> &#32; <a href="https://www.reddit.com/r/django/comments/1qs5ewy/architecture_comparison_django_vs_fastapi/">[comments]</a>

Explanation
 This visualizations work by assigning every file a dot.
  
Green = Low Complexity
 Red = High Complexity
  
Complexity is defined as Cyclomatic complexity (Mc. Cabe).
 The first image is Fast APIs dependency graph.
 Very structured and modularized. Very few Complex files and lower rates of connection between files. Most of the files are tests and tutorials.
 The second image shows Djangos graph:
 Much more interconnected and less modularized. More high complexity files but again most of the codebase is related to testing.
 Hope you found the comparison as interesting as I did!
 Edit: Django is a Batteries included framework with pre build auth and many other features whilst FastAPI takes a more lightweight approach.
    submitted by    /u/swupel_  
 [link]   [comments]

Architecture Comparison Django vs. FastAPI

<div class="md">After struggling to find a proper deployment guide that wasn&#39;t &quot;just use Heroku,&quot; I wrote the tutorial I wish I had. Covers: - Multi-stage Docker builds - Docker Compose orchestration - Nginx reverse proxy with SSL - Let&#39;s Encrypt setup - PostgreSQL in containers - Production security settings Full guide: <a href="https://bhusalmanish.com.np/blog/posts/deploy-drf-production.html">https://bhusalmanish.com.np/blog/posts/deploy-drf-production.html</a> Hope it helps someone. Happy to answer questions. </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/Ok-Childhood-5005"> /u/Ok-Childhood-5005 </a> <a href="https://www.reddit.com/r/django/comments/1qsyqva/i_wrote_a_complete_guide_to_deploying_drf_to/">[link]</a> &#32; <a href="https://www.reddit.com/r/django/comments/1qsyqva/i_wrote_a_complete_guide_to_deploying_drf_to/">[comments]</a>

After struggling to find a proper deployment guide that wasn't "just use Heroku," 
 I wrote the tutorial I wish I had.
 Covers:
 - Multi-stage Docker builds
 - Docker Compose orchestration 
 - Nginx reverse proxy with SSL
 - Let's Encrypt setup
 - PostgreSQL in containers
 - Production security settings
 Full guide: https://bhusalmanish.com.np/blog/posts/deploy-drf-production.html
 Hope it helps someone. Happy to answer questions.
    submitted by    /u/Ok-Childhood-5005  
 [link]   [comments]

I wrote a complete guide to deploying DRF to production with Docker, Nginx, and SSL

&#32; submitted by &#32; <a href="https://www.reddit.com/user/dwaxe"> /u/dwaxe </a> <a href="https://www.djangoproject.com/weblog/2026/feb/03/security-releases/">[link]</a> &#32; <a href="https://www.reddit.com/r/django/comments/1qut6yx/django_security_releases_issued_602_5211_and_4228/">[comments]</a>

submitted by    /u/dwaxe  
 [link]   [comments]

Django security releases issued: 6.0.2, 5.2.11, and 4.2.28

<div class="md">I’ve been using Django for a while, but I’m still confused about how industry-level Django backends are actually structured. Most tutorials show very basic structures like: app/ <a href="http://models.py">models.py</a> <a href="http://views.py">views.py</a> <a href="http://serializers.py">serializers.py</a> And most “advanced” examples just point to cookiecutter Django, which feels over-engineered and not very educational for understanding the core architecture. I don’t want tools, DevOps, Docker, CI/CD, or setup guides. I just want to understand: <ul> <li>How do real companies organize Django backend folders?</li> <li>How do they structure apps in large-scale projects?</li> <li>Where do business logic, services, and domains actually live?</li> <li>Do companies prefer monolith or domain-based apps in Django?</li> <li>Are there any real-world GitHub repositories that show a clean, production-grade folder structure (without cookiecutter)?</li> </ul> Basically, I want to learn the pure architectural folder structure of a scalable Django backend. If you’ve worked on production Django projects, how do you structure them and why? </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/Money_Consequence511"> /u/Money_Consequence511 </a> <a href="https://www.reddit.com/r/django/comments/1qvscci/what_does_a_real_productionlevel_django_backend/">[link]</a> &#32; <a href="https://www.reddit.com/r/django/comments/1qvscci/what_does_a_real_productionlevel_django_backend/">[comments]</a>

I’ve been using Django for a while, but I’m still confused about how industry-level Django backends are actually structured.
 Most tutorials show very basic structures like: 
 app/
 models.py
 views.py
 serializers.py
 And most “advanced” examples just point to cookiecutter Django, which feels over-engineered and not very educational for understanding the core architecture.
 I don’t want tools, DevOps, Docker, CI/CD, or setup guides.
 I just want to understand:
  
How do real companies organize Django backend folders?
 How do they structure apps in large-scale projects?
 Where do business logic, services, and domains actually live?
 Do companies prefer monolith or domain-based apps in Django?
 Are there any real-world GitHub repositories that show a clean, production-grade folder structure (without cookiecutter)?
  
Basically, I want to learn the pure architectural folder structure of a scalable Django backend.
 If you’ve worked on production Django projects, how do you structure them and why?
    submitted by    /u/Money_Consequence511  
 [link]   [comments]

What does a real production-level Django backend folder structure look like?

&#32; submitted by &#32; <a href="https://www.reddit.com/user/dwaxe"> /u/dwaxe </a> <a href="https://www.djangoproject.com/weblog/2026/feb/04/recent-trends-security-team/">[link]</a> &#32; <a href="https://www.reddit.com/r/django/comments/1qvskp8/recent_trends_in_the_work_of_the_django_security/">[comments]</a>

Recent trends in the work of the Django Security Team

<div class="md">Hello everyone, for a SAAS project I&#39;m interested in doing with Django, I found &quot;Django Multitenant,&quot; but looking at its repository, I haven&#39;t seen that it&#39;s very active in releasing updates. Is there anyone who is already using it or has used it who can give me their opinion, or are there better alternatives? Project link: <a href="https://github.com/citusdata/django-multitenant">https://github.com/citusdata/django-multitenant</a> </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/josueygp"> /u/josueygp </a> <a href="https://www.reddit.com/r/django/comments/1qu31ra/is_django_multitenant_really_worth_implementing/">[link]</a> &#32; <a href="https://www.reddit.com/r/django/comments/1qu31ra/is_django_multitenant_really_worth_implementing/">[comments]</a>

Hello everyone, for a SAAS project I'm interested in doing with Django, I found "Django Multitenant," but looking at its repository, I haven't seen that it's very active in releasing updates. Is there anyone who is already using it or has used it who can give me their opinion, or are there better alternatives?
 Project link:
 https://github.com/citusdata/django-multitenant
    submitted by    /u/josueygp  
 [link]   [comments]

Is Django Multitenant really worth implementing in 2026?

<div class="md">Hello everyone I&#39;ve just released dj-wallet – a lightweight and secure package for adding virtual wallet/balance functionality to your Django app. I packaged it because it&#39;s a very common feature, especially in projects like e-commerce, LMS, and fintech. It’s perfect for things like: - In-app credits or points - Virtual marketplaces - Reward or tipping systems What it does: - Users can deposit, withdraw, and transfer virtual - funds. - polymorphic-based wallet (User or any model) - Supports multiple wallets per user (e.g., “main”, “savings”). - Easy product purchasing system. Think of it like the wallet/balance system you see on Hostinger (for hosting credits) or similar platforms – but for your own Django project. If you find it useful, consider support me with a star. Ideas, questions, and PRs are welcome. <a href="https://github.com/khaledsukkar2/dj-wallet">https://github.com/khaledsukkar2/dj-wallet</a> </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/Advanced-Buy2218"> /u/Advanced-Buy2218 </a> <a href="https://www.reddit.com/r/django/comments/1qsat4r/introducing_djwallet_a_simple_virtual_wallet/">[link]</a> &#32; <a href="https://www.reddit.com/r/django/comments/1qsat4r/introducing_djwallet_a_simple_virtual_wallet/">[comments]</a>

Hello everyone I've just released dj-wallet – a lightweight and secure package for adding virtual wallet/balance functionality to your Django app.
 I packaged it because it's a very common feature, especially in projects like e-commerce, LMS, and fintech.
 It’s perfect for things like: - In-app credits or points - Virtual marketplaces - Reward or tipping systems
 What it does: - Users can deposit, withdraw, and transfer virtual - funds. - polymorphic-based wallet (User or any model) - Supports multiple wallets per user (e.g., “main”, “savings”). - Easy product purchasing system.
 Think of it like the wallet/balance system you see on Hostinger (for hosting credits) or similar platforms – but for your own Django project.
 If you find it useful, consider support me with a star.
 Ideas, questions, and PRs are welcome.
 https://github.com/khaledsukkar2/dj-wallet
    submitted by    /u/Advanced-Buy2218  
 [link]   [comments]

Introducing dj-wallet – A simple virtual wallet system for Django

<div class="md">I really enjoyed this talk this weekend, looks like it could add some good improvements to the Django admin. <a href="https://fosdem.org/2026/schedule/event/UBNWNL-django-admin-deux/">https://fosdem.org/2026/schedule/event/UBNWNL-django-admin-deux/</a> </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/Mathiasdm"> /u/Mathiasdm </a> <a href="https://www.reddit.com/r/django/comments/1qwwl17/is_it_time_for_a_django_admin_rewrite_fosdem_talk/">[link]</a> &#32; <a href="https://www.reddit.com/r/django/comments/1qwwl17/is_it_time_for_a_django_admin_rewrite_fosdem_talk/">[comments]</a>

I really enjoyed this talk this weekend, looks like it could add some good improvements to the Django admin.
 https://fosdem.org/2026/schedule/event/UBNWNL-django-admin-deux/
    submitted by    /u/Mathiasdm  
 [link]   [comments]

Is it time for a Django admin rewrite? (FOSDEM talk)

&#32; submitted by &#32; <a href="https://www.reddit.com/user/tanrax"> /u/tanrax </a> <a href="https://en.andros.dev/blog/94d14a9e/from-htmx-to-django-liveview/">[link]</a> &#32; <a href="https://www.reddit.com/r/django/comments/1qumr3i/from_htmx_to_django_liveview/">[comments]</a>

submitted by    /u/tanrax  
 [link]   [comments]

From htmx to Django LiveView

<div class="md">TL;DR: Built a framework that generates complete async CRUD APIs from Django models. Define schemas on your models, register a ViewSet, get 5 REST endpoints automatically. Full async, filtering, pagination, auth, and relationship support. <hr/> <h3>The Problem</h3> I love Django and Django Ninja, but I was tired of writing the same CRUD patterns over and over: <ul> <li>Creating separate serializer classes for input/output</li> <li>Writing list, create, retrieve, update, delete views manually</li> <li>Repeating the same filtering and pagination logic</li> <li>Handling M2M relationships with custom endpoints</li> <li>Configuring auth on each operation</li> </ul> For most models, 90% of the code was identical boilerplate. <hr/> <h3>The Solution: Django Ninja AIO CRUD</h3> I built a framework that automates all of this while staying flexible for customization. Here&#39;s a complete example: ```python <h1>models.py</h1> from django.db import models from ninja_aio.models import ModelSerializer class Book(ModelSerializer): title = models.CharField(max_length=120) published = models.BooleanField(default=True) <pre><code>class ReadSerializer: fields = [&quot;id&quot;, &quot;title&quot;, &quot;published&quot;] class CreateSerializer: fields = [&quot;title&quot;, &quot;published&quot;] class UpdateSerializer: optionals = [(&quot;title&quot;, str), (&quot;published&quot;, bool)] </code></pre> <h1>views.py</h1> from ninja_aio import NinjaAIO from ninja_aio.views import APIViewSet from .models import Book api = NinjaAIO() @api.viewset(Book) class BookViewSet(APIViewSet): pass ``` That&#39;s it. You now have: - <code>GET /book/</code> - List with pagination - <code>POST /book/</code> - Create - <code>GET /book/{pk}</code> - Retrieve - <code>PATCH /book/{pk}</code> - Update - <code>DELETE /book/{pk}</code> - Delete <hr/> <h3>Key Features</h3> <table><thead> <tr> <th>Feature</th> <th>Description</th> </tr> </thead><tbody> <tr> <td>Meta-driven Serializer</td> <td>Generate CRUD schemas for existing Django models without changing base classes</td> </tr> <tr> <td>Async CRUD ViewSets</td> <td>All operations fully async</td> </tr> <tr> <td>Auto Schemas</td> <td>Automatic read/create/update schemas from ModelSerializer</td> </tr> <tr> <td>Dynamic Query Params</td> <td>Runtime filter schemas with <code>pydantic.create_model</code></td> </tr> <tr> <td>Per-method Auth</td> <td><code>auth</code>, <code>get_auth</code>, <code>post_auth</code>, etc. for granular control</td> </tr> <tr> <td>Async Pagination</td> <td>Fully async, pluggable pagination classes</td> </tr> <tr> <td>M2M Relations</td> <td>Add/remove/list endpoints with filtering</td> </tr> <tr> <td>Reverse Relations</td> <td>Automatic nested serialization</td> </tr> <tr> <td>Lifecycle Hooks</td> <td><code>before_save</code>, <code>after_save</code>, <code>on_delete</code>, etc.</td> </tr> <tr> <td>Schema Validators</td> <td>Pydantic validators on serializer classes</td> </tr> <tr> <td>ORJSON Renderer</td> <td>Fast JSON via NinjaAIO</td> </tr> </tbody></table> <hr/> <h3>Two Patterns: Choose What Fits</h3> Option A: ModelSerializer (for new projects) ```python class Article(ModelSerializer): title = models.CharField(max_length=200) author = models.ForeignKey(User, on_delete=models.CASCADE) <pre><code>class ReadSerializer: fields = [&quot;id&quot;, &quot;title&quot;, &quot;author&quot;] class CreateSerializer: fields = [&quot;title&quot;, &quot;author&quot;] </code></pre> ``` Option B: Meta-driven Serializer (for existing models) <code>python class ArticleSerializer(serializers.Serializer): class Meta: model = models.Article schema_in = serializers.SchemaModelConfig(fields=[&quot;title&quot;, &quot;author&quot;]) schema_out = serializers.SchemaModelConfig(fields=[&quot;id&quot;, &quot;title&quot;, &quot;author&quot;]) </code> No need to change your existing Django models! <hr/> <h3>Advanced Example: Blog API with Relationships</h3> ```python class Author(ModelSerializer): name = models.CharField(max_length=200) email = models.EmailField(unique=True) <pre><code>class ReadSerializer: fields = [&quot;id&quot;, &quot;name&quot;, &quot;email&quot;, &quot;articles&quot;] </code></pre> class Article(ModelSerializer): title = models.CharField(max_length=200) author = models.ForeignKey(Author, on_delete=models.CASCADE, related_name=&quot;articles&quot;) tags = models.ManyToManyField(&#39;Tag&#39;, related_name=&quot;articles&quot;) <pre><code>class ReadSerializer: fields = [&quot;id&quot;, &quot;title&quot;, &quot;author&quot;, &quot;tags&quot;] class CreateSerializer: fields = [&quot;title&quot;, &quot;author&quot;] customs = [(&quot;notify_subscribers&quot;, bool, True)] async def custom_actions(self, payload: dict): if payload.get(&quot;notify_subscribers&quot;): await notify_new_article(self) </code></pre> @api.viewset(Article) class ArticleViewSet(APIViewSet): query_params = {&quot;author&quot;: (int, None), &quot;title&quot;: (str, None)} <pre><code>m2m_relations = [ M2MRelationSchema( model=Tag, related_name=&quot;tags&quot;, filters={&quot;name&quot;: (str, &quot;&quot;)} ) ] async def query_params_handler(self, queryset, filters): if filters.get(&quot;author&quot;): queryset = queryset.filter(author_id=filters[&quot;author&quot;]) if filters.get(&quot;title&quot;): queryset = queryset.filter(title__icontains=filters[&quot;title&quot;]) return queryset async def tags_query_params_handler(self, queryset, filters): if filters.get(&quot;name&quot;): queryset = queryset.filter(name__icontains=filters[&quot;name&quot;]) return queryset </code></pre> ``` This gives you: - Full CRUD for articles - Nested author and tags in responses - Filtering by author and title - M2M endpoints: <code>GET /article/{pk}/tag?name=python</code> and <code>POST /article/{pk}/tag/</code> - Custom action for notifications <hr/> <h3>Schema Validators (Pydantic)</h3> Add <code>@field_validator</code> and <code>@model_validator</code> directly on serializer classes: ```python class Book(ModelSerializer): title = models.CharField(max_length=120) <pre><code>class CreateSerializer: fields = [&quot;title&quot;] @field_validator(&quot;title&quot;) @classmethod def validate_title_min_length(cls, v): if len(v) &lt; 3: raise ValueError(&quot;Title must be at least 3 characters&quot;) return v </code></pre> ``` The framework automatically collects validators and applies them to the generated Pydantic schemas. <hr/> <h3>Authentication Example (JWT)</h3> ```python from ninja_aio.auth import AsyncJwtBearer from joserfc import jwk class JWTAuth(AsyncJwtBearer): jwt_public = jwk.RSAKey.import_key(&quot;-----BEGIN PUBLIC KEY----- ...&quot;) jwt_alg = &quot;RS256&quot; claims = {&quot;sub&quot;: {&quot;essential&quot;: True}} <pre><code>async def auth_handler(self, request): user_id = self.dcd.claims.get(&quot;sub&quot;) return await User.objects.aget(id=user_id) </code></pre> @api.viewset(Book) class SecureBookViewSet(APIViewSet): auth = [JWTAuth()] get_auth = None # list/retrieve remain public post_auth = [JWTAuth()] # create requires auth ``` <hr/> <h3>Performance</h3> Performance is a priority: <ul> <li>Built on Django Ninja (one of the fastest Python frameworks)</li> <li>Full async/await support</li> <li>orjson for fast JSON serialization</li> <li>Automated performance benchmarks in CI</li> </ul> Live Benchmarks: <a href="https://caspel26.github.io/django-ninja-aio-crud/">https://caspel26.github.io/django-ninja-aio-crud/</a> Current results (schema generation, serialization, CRUD operations): - Single object serialization: ~0.5-1ms - Bulk serialization (100 objects): ~5-15ms - Full CRUD endpoint cycle: ~2-8ms <hr/> <h3>Quality &amp; Testing</h3> <ul> <li>98%+ test coverage (Codecov)</li> <li>SonarCloud quality gate passing</li> <li>Automated performance regression detection</li> <li>Supports Python 3.10-3.14</li> <li>Compatible with Django Ninja 1.3-1.5</li> <li>MIT License</li> </ul> Badges: <a href="https://github.com/caspel26/django-ninja-aio-crud/actions">![Tests](https://github.com/caspel26/django-ninja-aio-crud/actions/workflows/coverage.yml/badge.svg)</a> <a href="https://sonarcloud.io/summary/new_code?id=caspel26_django-ninja-aio-crud">![Quality Gate](https://sonarcloud.io/api/project_badges/measure?project=caspel26_django-ninja-aio-crud&amp;metric=alert_status)</a> <a href="https://codecov.io/gh/caspel26/django-ninja-aio-crud">![codecov](https://codecov.io/gh/caspel26/django-ninja-aio-crud/graph/badge.svg?token=DZ5WDT3S20)</a> <hr/> <h3>Installation &amp; Quick Start</h3> <code>bash pip install django-ninja-aio-crud </code> ```python <h1>settings.py</h1> INSTALLED_APPS = [ # ... &#39;ninja_aio&#39;, ] <h1>models.py</h1> from ninja_aio.models import ModelSerializer class Book(ModelSerializer): title = models.CharField(max_length=120) <pre><code>class ReadSerializer: fields = [&quot;id&quot;, &quot;title&quot;] class CreateSerializer: fields = [&quot;title&quot;] </code></pre> <h1>urls.py</h1> from ninja_aio import NinjaAIO from ninja_aio.views import APIViewSet from .models import Book api = NinjaAIO() @api.viewset(Book) class BookViewSet(APIViewSet): pass urlpatterns = [ path(&quot;api/&quot;, api.urls), ] ``` Visit <code>http://localhost:8000/api/docs</code> - your CRUD endpoints are ready! <hr/> <h3>Links</h3> <ul> <li>Documentation: <a href="https://django-ninja-aio.com">https://django-ninja-aio.com</a></li> <li>GitHub: <a href="https://github.com/caspel26/django-ninja-aio-crud">https://github.com/caspel26/django-ninja-aio-crud</a></li> <li>PyPI: <a href="https://pypi.org/project/django-ninja-aio-crud/">https://pypi.org/project/django-ninja-aio-crud/</a></li> <li>Example Project: <a href="https://github.com/caspel26/ninja-aio-blog-example">https://github.com/caspel26/ninja-aio-blog-example</a></li> <li>Performance Benchmarks: <a href="https://caspel26.github.io/django-ninja-aio-crud/">https://caspel26.github.io/django-ninja-aio-crud/</a></li> </ul> <hr/> <h3>Why I Built This</h3> I&#39;ve been building Django APIs for years, and I noticed I was writing the same patterns repeatedly. DRF is powerful but verbose. Django Ninja improved the DX significantly, but CRUD still required boilerplate. I wanted something that: 1. Eliminates repetitive code 2. Stays fully async 3. Remains flexible for complex cases 4. Doesn&#39;t hide Django&#39;s ORM 5. Provides excellent performance Django Ninja AIO CRUD is the result. It&#39;s opinionated where it helps (CRUD patterns) and flexible where it matters (customization). <hr/> <h3>Feedback Welcome</h3> This is an open-source project and I&#39;d love your feedback: <ul> <li>What features would you want?</li> <li>What pain points does this solve (or not solve) for you?</li> <li>What documentation would help?</li> </ul> ⭐ Star on GitHub if you find it useful! Happy to answer questions in the comments! <hr/> </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/peppe2612"> /u/peppe2612 </a> <a href="https://www.reddit.com/r/django/comments/1qsv3l7/tired_of_writing_crud_boilerplate_django_ninja/">[link]</a> &#32; <a href="https://www.reddit.com/r/django/comments/1qsv3l7/tired_of_writing_crud_boilerplate_django_ninja/">[comments]</a>

TL;DR: Built a framework that generates complete async CRUD APIs from Django models. Define schemas on your models, register a ViewSet, get 5 REST endpoints automatically. Full async, filtering, pagination, auth, and relationship support.
 
The Problem
 I love Django and Django Ninja, but I was tired of writing the same CRUD patterns over and over:
 
Creating separate serializer classes for input/output
 Writing list, create, retrieve, update, delete views manually
 Repeating the same filtering and pagination logic
 Handling M2M relationships with custom endpoints
 Configuring auth on each operation
 
For most models, 90% of the code was identical boilerplate.
 
The Solution: Django Ninja AIO CRUD
 I built a framework that automates all of this while staying flexible for customization.
 Here's a complete example:
 ```python
 models.py
 from django.db import models from ninja_aio.models import ModelSerializer
 class Book(ModelSerializer): title = models.CharField(max_length=120) published = models.BooleanField(default=True)
 class ReadSerializer: fields = ["id", "title", "published"] class CreateSerializer: fields = ["title", "published"] class UpdateSerializer: optionals = [("title", str), ("published", bool)] 
 views.py
 from ninja_aio import NinjaAIO from ninja_aio.views import APIViewSet from .models import Book
 api = NinjaAIO()
 @api.viewset(Book) class BookViewSet(APIViewSet): pass ```
 That's it. You now have: - GET /book/ - List with pagination - POST /book/ - Create - GET /book/{pk} - Retrieve - PATCH /book/{pk} - Update - DELETE /book/{pk} - Delete
 
Key Features
 
 Feature Description 
 
 Meta-driven Serializer Generate CRUD schemas for existing Django models without changing base classes 
 Async CRUD ViewSets All operations fully async 
 Auto Schemas Automatic read/create/update schemas from ModelSerializer 
 Dynamic Query Params Runtime filter schemas with pydantic.create_model 
 Per-method Auth auth, get_auth, post_auth, etc. for granular control 
 Async Pagination Fully async, pluggable pagination classes 
 M2M Relations Add/remove/list endpoints with filtering 
 Reverse Relations Automatic nested serialization 
 Lifecycle Hooks before_save, after_save, on_delete, etc. 
 Schema Validators Pydantic validators on serializer classes 
 ORJSON Renderer Fast JSON via NinjaAIO 
 
 
Two Patterns: Choose What Fits
 Option A: ModelSerializer (for new projects)
 ```python class Article(ModelSerializer): title = models.CharField(max_length=200) author = models.ForeignKey(User, on_delete=models.CASCADE)
 class ReadSerializer: fields = ["id", "title", "author"] class CreateSerializer: fields = ["title", "author"] 
 ```
 Option B: Meta-driven Serializer (for existing models)
 python class ArticleSerializer(serializers.Serializer): class Meta: model = models.Article schema_in = serializers.SchemaModelConfig(fields=["title", "author"]) schema_out = serializers.SchemaModelConfig(fields=["id", "title", "author"]) 
 No need to change your existing Django models!
 
Advanced Example: Blog API with Relationships
 ```python class Author(ModelSerializer): name = models.CharField(max_length=200) email = models.EmailField(unique=True)
 class ReadSerializer: fields = ["id", "name", "email", "articles"] 
 class Article(ModelSerializer): title = models.CharField(max_length=200) author = models.ForeignKey(Author, on_delete=models.CASCADE, related_name="articles") tags = models.ManyToManyField('Tag', related_name="articles")
 class ReadSerializer: fields = ["id", "title", "author", "tags"] class CreateSerializer: fields = ["title", "author"] customs = [("notify_subscribers", bool, True)] async def custom_actions(self, payload: dict): if payload.get("notify_subscribers"): await notify_new_article(self) 
 @api.viewset(Article) class ArticleViewSet(APIViewSet): query_params = {"author": (int, None), "title": (str, None)}
 m2m_relations = [ M2MRelationSchema( model=Tag, related_name="tags", filters={"name": (str, "")} ) ] async def query_params_handler(self, queryset, filters): if filters.get("author"): queryset = queryset.filter(author_id=filters["author"]) if filters.get("title"): queryset = queryset.filter(title__icontains=filters["title"]) return queryset async def tags_query_params_handler(self, queryset, filters): if filters.get("name"): queryset = queryset.filter(name__icontains=filters["name"]) return queryset 
 ```
 This gives you: - Full CRUD for articles - Nested author and tags in responses - Filtering by author and title - M2M endpoints: GET /article/{pk}/tag?name=python and POST /article/{pk}/tag/ - Custom action for notifications
 
Schema Validators (Pydantic)
 Add @field_validator and @model_validator directly on serializer classes:
 ```python class Book(ModelSerializer): title = models.CharField(max_length=120)
 class CreateSerializer: fields = ["title"] @field_validator("title") @classmethod def validate_title_min_length(cls, v): if len(v) < 3: raise ValueError("Title must be at least 3 characters") return v 
 ```
 The framework automatically collects validators and applies them to the generated Pydantic schemas.
 
Authentication Example (JWT)
 ```python from ninja_aio.auth import AsyncJwtBearer from joserfc import jwk
 class JWTAuth(AsyncJwtBearer): jwt_public = jwk.RSAKey.import_key("-----BEGIN PUBLIC KEY----- ...") jwt_alg = "RS256" claims = {"sub": {"essential": True}}
 async def auth_handler(self, request): user_id = self.dcd.claims.get("sub") return await User.objects.aget(id=user_id) 
 @api.viewset(Book) class SecureBookViewSet(APIViewSet): auth = [JWTAuth()] get_auth = None # list/retrieve remain public post_auth = [JWTAuth()] # create requires auth ```
 
Performance
 Performance is a priority:
 
Built on Django Ninja (one of the fastest Python frameworks)
 Full async/await support
 orjson for fast JSON serialization
 Automated performance benchmarks in CI
 
Live Benchmarks: https://caspel26.github.io/django-ninja-aio-crud/
 Current results (schema generation, serialization, CRUD operations): - Single object serialization: ~0.5-1ms - Bulk serialization (100 objects): ~5-15ms - Full CRUD endpoint cycle: ~2-8ms
 
Quality & Testing
 
98%+ test coverage (Codecov)
 SonarCloud quality gate passing
 Automated performance regression detection
 Supports Python 3.10-3.14
 Compatible with Django Ninja 1.3-1.5
 MIT License
 
Badges: ![Tests](https://github.com/caspel26/django-ninja-aio-crud/actions/workflows/coverage.yml/badge.svg) ![Quality Gate](https://sonarcloud.io/api/project_badges/measure?project=caspel26_django-ninja-aio-crud&metric=alert_status) ![codecov](https://codecov.io/gh/caspel26/django-ninja-aio-crud/graph/badge.svg?token=DZ5WDT3S20)
 
Installation & Quick Start
 bash pip install django-ninja-aio-crud 
 ```python
 settings.py
 INSTALLED_APPS = [ # ... 'ninja_aio', ]
 models.py
 from ninja_aio.models import ModelSerializer
 class Book(ModelSerializer): title = models.CharField(max_length=120)
 class ReadSerializer: fields = ["id", "title"] class CreateSerializer: fields = ["title"] 
 urls.py
 from ninja_aio import NinjaAIO from ninja_aio.views import APIViewSet from .models import Book
 api = NinjaAIO()
 @api.viewset(Book) class BookViewSet(APIViewSet): pass
 urlpatterns = [ path("api/", api.urls), ] ```
 Visit http://localhost:8000/api/docs - your CRUD endpoints are ready!
 
Links
 
Documentation: https://django-ninja-aio.com
 GitHub: https://github.com/caspel26/django-ninja-aio-crud
 PyPI: https://pypi.org/project/django-ninja-aio-crud/
 Example Project: https://github.com/caspel26/ninja-aio-blog-example
 Performance Benchmarks: https://caspel26.github.io/django-ninja-aio-crud/
 
 Why I Built This
 I've been building Django APIs for years, and I noticed I was writing the same patterns repeatedly. DRF is powerful but verbose. Django Ninja improved the DX significantly, but CRUD still required boilerplate.
 I wanted something that: 1. Eliminates repetitive code 2. Stays fully async 3. Remains flexible for complex cases 4. Doesn't hide Django's ORM 5. Provides excellent performance
 Django Ninja AIO CRUD is the result. It's opinionated where it helps (CRUD patterns) and flexible where it matters (customization).
 
Feedback Welcome
 This is an open-source project and I'd love your feedback:
 
What features would you want?
 What pain points does this solve (or not solve) for you?
 What documentation would help?
 
⭐ Star on GitHub if you find it useful!
 Happy to answer questions in the comments!
 
 submitted by /u/peppe2612 
 [link] [comments]

Tired of writing CRUD boilerplate? Django Ninja AIO CRUD 2.18.0 is here!

<div class="md">Hi <a href="/r/django">r/django</a>! Welcome to another post in this series. Below, you&#39;ll find all the Django conference talks and podcasts published in the last 7 days: <h1>📺 Conference talks</h1> <h1>DjangoCon US 2025</h1> <ol> <li><a href="https://youtube.com/watch?v=CzXV5pwU7zc">&quot;DjangoCon US 2025 - Winemaking with Mutable Event Sourcing in Django with Chris Muthig&quot;</a> ⸱ &lt;100 views ⸱ 01 Feb 2026 ⸱ 00h 45m 38s</li> <li><a href="https://youtube.com/watch?v=OvRS1C7rpto">&quot;DjangoCon US 2025 - Hidden Dangers Of AI In Developer Workflows: Navigating... with Dwayne McDaniel&quot;</a> ⸱ &lt;100 views ⸱ 31 Jan 2026 ⸱ 00h 26m 41s</li> <li><a href="https://youtube.com/watch?v=hGe_Q-BjDDs">&quot;DjangoCon US 2025 - What would the django of data pipelines look like? with Lisa Dusseault&quot;</a> ⸱ &lt;100 views ⸱ 28 Jan 2026 ⸱ 00h 22m 50s</li> <li><a href="https://youtube.com/watch?v=iDqXUxDRDRw">&quot;DjangoCon US 2025 - Cutting latency in half: What actually worked—and... with Timothy Mccurrach&quot;</a> ⸱ &lt;100 views ⸱ 31 Jan 2026 ⸱ 00h 44m 42s</li> <li><a href="https://youtube.com/watch?v=90QLYTSQOZU">&quot;DjangoCon US 2025 - Keynote: All The Ways To Use Django with Zags (Benjamin Zagorsky)&quot;</a> ⸱ &lt;100 views ⸱ 02 Feb 2026 ⸱ 00h 44m 54s</li> <li><a href="https://youtube.com/watch?v=xqQNOvMYRYI">&quot;DjangoCon US 2025 - Entering the World of CMS with Wagtail with Michael Riley&quot;</a> ⸱ &lt;100 views ⸱ 29 Jan 2026 ⸱ 00h 40m 08s</li> <li><a href="https://youtube.com/watch?v=5fonCHDtvPg">&quot;DjangoCon US 2025 - Lightning Talks (Wednesday) with Andrew Mshar&quot;</a> ⸱ &lt;100 views ⸱ 30 Jan 2026 ⸱ 00h 38m 12s</li> <li><a href="https://youtube.com/watch?v=N6P-4tpv7uE">&quot;DjangoCon US 2025 - What a Decade! with Timothy Allen&quot;</a> ⸱ &lt;100 views ⸱ 30 Jan 2026 ⸱ 00h 43m 44s</li> <li><a href="https://youtube.com/watch?v=_1fWVocF1DI">&quot;DjangoCon US 2025 - Django as a Database Documentation Tool: The Hidden Power... with Ryan Cheley&quot;</a> ⸱ &lt;100 views ⸱ 28 Jan 2026 ⸱ 00h 24m 26s</li> <li><a href="https://youtube.com/watch?v=TFMyf-UZ4NY">&quot;DjangoCon US 2025 - Panel Discussion: Two Decades of Django with Velda Kiara&quot;</a> ⸱ &lt;100 views ⸱ 01 Feb 2026 ⸱ 00h 57m 40s</li> <li><a href="https://youtube.com/watch?v=9Jneo_fP6qI">&quot;DjangoCon US 2025 - Python for Planet Earth: Climate Modeling and Sustainability.. with Drishti Jain&quot;</a> ⸱ &lt;100 views ⸱ 29 Jan 2026 ⸱ 00h 27m 31s</li> <li><a href="https://youtube.com/watch?v=AkGZXetGwN0">&quot;DjangoCon US 2025 - Reverse engineering the QR code generator and URL forwarder... with Mariatta&quot;</a> ⸱ &lt;100 views ⸱ 03 Feb 2026 ⸱ 00h 32m 00s</li> <li><a href="https://youtube.com/watch?v=e1K8S3Vdmnk">&quot;DjangoCon US 2025 - Opening Remarks (Day 2) with Peter Grandstaff&quot;</a> ⸱ &lt;100 views ⸱ 03 Feb 2026 ⸱ 00h 11m 20s</li> </ol> <h1>🎧 Podcasts</h1> <ol> <li><a href="https://pythonbytes.fm/episodes/show/468/a-bolt-of-django">&quot;#468 A bolt of Django&quot;</a> ⸱ Python Bytes ⸱ 03 Feb 2026 ⸱ 00h 31m 00s</li> </ol> This post is an excerpt from the latest issue of <a href="https://www.techtalksweekly.io/">Tech Talks Weekly</a> which is a free weekly email with all the recently published Software Engineering and Development conference talks &amp; podcasts. Currently subscribed by +8,200 Software Engineers who stopped scrolling through messy YouTube subscriptions and reduced FOMO. Consider subscribing if this sounds useful: <a href="https://www.techtalksweekly.io/">https://www.techtalksweekly.io/</a> Let me know what you think. Thank you! </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/TechTalksWeekly"> /u/TechTalksWeekly </a> <a href="https://www.reddit.com/r/django/comments/1qwoten/django_podcasts_conference_talks_week_6_2025/">[link]</a> &#32; <a href="https://www.reddit.com/r/django/comments/1qwoten/django_podcasts_conference_talks_week_6_2025/">[comments]</a>

Hi r/django! Welcome to another post in this series. Below, you'll find all the Django conference talks and podcasts published in the last 7 days:
 📺 Conference talks
 DjangoCon US 2025
 
"DjangoCon US 2025 - Winemaking with Mutable Event Sourcing in Django with Chris Muthig" ⸱ <100 views ⸱ 01 Feb 2026 ⸱ 00h 45m 38s
 "DjangoCon US 2025 - Hidden Dangers Of AI In Developer Workflows: Navigating... with Dwayne McDaniel" ⸱ <100 views ⸱ 31 Jan 2026 ⸱ 00h 26m 41s
 "DjangoCon US 2025 - What would the django of data pipelines look like? with Lisa Dusseault" ⸱ <100 views ⸱ 28 Jan 2026 ⸱ 00h 22m 50s
 "DjangoCon US 2025 - Cutting latency in half: What actually worked—and... with Timothy Mccurrach" ⸱ <100 views ⸱ 31 Jan 2026 ⸱ 00h 44m 42s
 "DjangoCon US 2025 - Keynote: All The Ways To Use Django with Zags (Benjamin Zagorsky)" ⸱ <100 views ⸱ 02 Feb 2026 ⸱ 00h 44m 54s
 "DjangoCon US 2025 - Entering the World of CMS with Wagtail with Michael Riley" ⸱ <100 views ⸱ 29 Jan 2026 ⸱ 00h 40m 08s
 "DjangoCon US 2025 - Lightning Talks (Wednesday) with Andrew Mshar" ⸱ <100 views ⸱ 30 Jan 2026 ⸱ 00h 38m 12s
 "DjangoCon US 2025 - What a Decade! with Timothy Allen" ⸱ <100 views ⸱ 30 Jan 2026 ⸱ 00h 43m 44s
 "DjangoCon US 2025 - Django as a Database Documentation Tool: The Hidden Power... with Ryan Cheley" ⸱ <100 views ⸱ 28 Jan 2026 ⸱ 00h 24m 26s
 "DjangoCon US 2025 - Panel Discussion: Two Decades of Django with Velda Kiara" ⸱ <100 views ⸱ 01 Feb 2026 ⸱ 00h 57m 40s
 "DjangoCon US 2025 - Python for Planet Earth: Climate Modeling and Sustainability.. with Drishti Jain" ⸱ <100 views ⸱ 29 Jan 2026 ⸱ 00h 27m 31s
 "DjangoCon US 2025 - Reverse engineering the QR code generator and URL forwarder... with Mariatta" ⸱ <100 views ⸱ 03 Feb 2026 ⸱ 00h 32m 00s
 "DjangoCon US 2025 - Opening Remarks (Day 2) with Peter Grandstaff" ⸱ <100 views ⸱ 03 Feb 2026 ⸱ 00h 11m 20s
 
🎧 Podcasts
 
"#468 A bolt of Django" ⸱ Python Bytes ⸱ 03 Feb 2026 ⸱ 00h 31m 00s
 
This post is an excerpt from the latest issue of Tech Talks Weekly which is a free weekly email with all the recently published Software Engineering and Development conference talks & podcasts. Currently subscribed by +8,200 Software Engineers who stopped scrolling through messy YouTube subscriptions and reduced FOMO. Consider subscribing if this sounds useful: https://www.techtalksweekly.io/
 Let me know what you think. Thank you!
 submitted by /u/TechTalksWeekly 
 [link] [comments]

Django Podcasts & Conference Talks (week 6, 2025)

<div class="md">I just switched from pre-commit to Prek, which is a pre-commit built with Rust, and the dev experience is awesome (zero-latency) I have seen many rust built tools to improve the dev experience in Python, and I recommend people here to give it a try. pip -&gt; uv Black -&gt; Ruff Mypy -&gt; ty </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/Michaelyin"> /u/Michaelyin </a> <a href="https://www.reddit.com/r/django/comments/1qwfrcb/you_need_to_replace_precommit_with_prek/">[link]</a> &#32; <a href="https://www.reddit.com/r/django/comments/1qwfrcb/you_need_to_replace_precommit_with_prek/">[comments]</a>

I just switched from pre-commit to Prek, which is a pre-commit built with Rust, and the dev experience is awesome (zero-latency)
 I have seen many rust built tools to improve the dev experience in Python, and I recommend people here to give it a try.
 pip -> uv
 Black -> Ruff
 Mypy -> ty
    submitted by    /u/Michaelyin  
 [link]   [comments]

You need to replace pre-commit with Prek

&#32; submitted by &#32; <a href="https://www.reddit.com/user/Late_Indication6341"> /u/Late_Indication6341 </a> <a href="https://i.redd.it/m8k11w4w2xgg1.jpeg">[link]</a> &#32; <a href="https://www.reddit.com/r/django/comments/1qt4fh5/data_of_big_tech_companies_uses_django_is_this/">[comments]</a>

submitted by    /u/Late_Indication6341  
 [link]   [comments]

Data of big tech companies uses django? Is this data is true generated by chatgpt and if not please someone give me reality check

<div class="md">Hi everyone, I just published a small repo to bootstrap a Django project using what I see as modern tools. What do you think? <a href="https://github.com/GaspardMerten/django-ninja-unfold">https://github.com/GaspardMerten/django-ninja-unfold</a> </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/gaspard-m"> /u/gaspard-m </a> <a href="https://www.reddit.com/r/django/comments/1qr4xvp/django_ninja_unfold_starter_template/">[link]</a> &#32; <a href="https://www.reddit.com/r/django/comments/1qr4xvp/django_ninja_unfold_starter_template/">[comments]</a>

Hi everyone,
 I just published a small repo to bootstrap a Django project using what I see as modern tools.
 What do you think?
 https://github.com/GaspardMerten/django-ninja-unfold
    submitted by    /u/gaspard-m  
 [link]   [comments]

Django - Ninja - Unfold starter template

<div class="md">Hello! I’m thinking of attending DjangoCon Europe 2026. I have never attended a conference before, but it’s something I’d like to try. Does anybody have experience with these events? Is it worth it? I’m a little nervous about going by myself. Also, I haven’t coded in Django for a year (I switched to Go), but I still like the framework and use many patterns in Go that I learned from it. </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/jozekuhar"> /u/jozekuhar </a> <a href="https://www.reddit.com/r/django/comments/1qsxu4r/djangocon_europe_2026/">[link]</a> &#32; <a href="https://www.reddit.com/r/django/comments/1qsxu4r/djangocon_europe_2026/">[comments]</a>

Hello! I’m thinking of attending DjangoCon Europe 2026. I have never attended a conference before, but it’s something I’d like to try. Does anybody have experience with these events? Is it worth it?
 I’m a little nervous about going by myself. Also, I haven’t coded in Django for a year (I switched to Go), but I still like the framework and use many patterns in Go that I learned from it.
    submitted by    /u/jozekuhar  
 [link]   [comments]

DjangoCon Europe 2026

<div class="md">I am building a management app for small organizations using our old friend django. As my first needs are purely basic CRUD operations on data, what about using the native django admin (+ unfold as theme improvement) as my frontend for a MVP ? I only see real gains in term of development time and maintenance as a solo dev. No frontend to build (juste override some django admin templates pages), reduced attack surface (authentication and authorizations managed by django if well limited by groups, permissions and django admin methods) and less dependency management time (you all know node modules massive dependencies and security issues) My plan is to launch my app with django admin (users views and actions will be limited) and eventually I would go for a dedicated modern frontend to improve UI/UX and turn django into an API and disabled access to the admin site. I would be really interested in having your thoughts on this idea. And finally, this sub is gold mine for people like me trying to improve their django skills and leaning new projects (thank you all !) </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/thomaskgt"> /u/thomaskgt </a> <a href="https://www.reddit.com/r/django/comments/1qtd4j6/thoughts_on_using_django_admin_with_a_good/">[link]</a> &#32; <a href="https://www.reddit.com/r/django/comments/1qtd4j6/thoughts_on_using_django_admin_with_a_good/">[comments]</a>

I am building a management app for small organizations using our old friend django.
 As my first needs are purely basic CRUD operations on data, what about using the native django admin (+ unfold as theme improvement) as my frontend for a MVP ?
 I only see real gains in term of development time and maintenance as a solo dev. No frontend to build (juste override some django admin templates pages), reduced attack surface (authentication and authorizations managed by django if well limited by groups, permissions and django admin methods) and less dependency management time (you all know node modules massive dependencies and security issues)
 My plan is to launch my app with django admin (users views and actions will be limited) and eventually I would go for a dedicated modern frontend to improve UI/UX and turn django into an API and disabled access to the admin site.
 I would be really interested in having your thoughts on this idea.
 And finally, this sub is gold mine for people like me trying to improve their django skills and leaning new projects (thank you all !)
    submitted by    /u/thomaskgt  
 [link]   [comments]

Thoughts on using django admin (with a good looking theme and restricted enough) as MVP ?

<div class="md">Hey folks I have a little hands on knowledge with Django but that was like 5 years back and no experience so far with FastAPI. I’m trying to write a webservice which will need heavy async script runs, example a python script running in background and saving its results on disk. I’m leaning towards Django because <ol> <li>It gives user segregation and permissions built in i.e admin, user, customer support etc</li> <li>ORM is really good although my requirements are basic </li> <li>I can do fast prototyping using web templates. Although I’ll need to switch to Rust, Vue or something in future for sure. But I have been told that FastAPI might be a better fit as its built for these kind of use cases especially async tasks, its lighter and my requirements can be managed here. </li> </ol> People who have worked on both or worked with heavy async/background tasks, I would like to hear your take on this. </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/Own-Eggplant5012"> /u/Own-Eggplant5012 </a> <a href="https://www.reddit.com/r/django/comments/1qwet3z/django_vs_fastapi_for_async_heavy_tasks/">[link]</a> &#32; <a href="https://www.reddit.com/r/django/comments/1qwet3z/django_vs_fastapi_for_async_heavy_tasks/">[comments]</a>

Hey folks
 I have a little hands on knowledge with Django but that was like 5 years back and no experience so far with FastAPI. 
 I’m trying to write a webservice which will need heavy async script runs, example a python script running in background and saving its results on disk. 
 I’m leaning towards Django because 
  
It gives user segregation and permissions built in i.e admin, user, customer support etc
 
ORM is really good although my requirements are basic 
 
I can do fast prototyping using web templates. Although I’ll need to switch to Rust, Vue or something in future for sure. 
 But I have been told that FastAPI might be a better fit as its built for these kind of use cases especially async tasks, its lighter and my requirements can be managed here. 
 
 People who have worked on both or worked with heavy async/background tasks, I would like to hear your take on this. 
    submitted by    /u/Own-Eggplant5012  
 [link]   [comments]

Django vs FastAPI for Async heavy tasks

&#32; submitted by &#32; <a href="https://www.reddit.com/user/Lazy_Equipment6485"> /u/Lazy_Equipment6485 </a> <a href="https://adrienvanthong.medium.com/django-hierarchical-models-dc40351c9f82">[link]</a> &#32; <a href="https://www.reddit.com/r/django/comments/1qrvow2/django_hierarchical_models/">[comments]</a>

Django Hierarchical models

&#32; submitted by &#32; <a href="https://www.reddit.com/user/meagenvoss"> /u/meagenvoss </a> <a href="https://i.redd.it/qh0ge38cachg1.png">[link]</a> &#32; <a href="https://www.reddit.com/r/django/comments/1qv3ez6/autosave_is_here_in_wagtail_73_and_many_other/">[comments]</a>

submitted by    /u/meagenvoss  
 [link]   [comments]

Autosave is here in Wagtail 7.3 (and many other great things!)

<div class="md">I’ve never worked in prod, I want to deploy and run real-world production apps on AWS, but I’m overwhelmed by the sheer number of services. My goal: Deploy Django/FastAPI APIs Use Postgres Handle background tasks Use cache like redis Store files Set up basic logging/monitoring Setup CDN What I’m looking for: A minimal, practical AWS stack I should focus on. Which services are must-learn vs safe to ignore early on Learning resources (courses, blogs, YouTube, hands-on repos) that are backend-dev focused, not DevOps-heavy For example: Is EC2 + RDS + S3 + IAM enough to start? Should I skip ECS/EKS/Lambda initially? What do Django teams actually use in production? I’d really appreciate advice from people running Django/FastAPI apps on AWS in real jobs. </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/adamfloyd1506"> /u/adamfloyd1506 </a> <a href="https://www.reddit.com/r/django/comments/1qr5mfp/what_resources_would_you_recommend_to_learn/">[link]</a> &#32; <a href="https://www.reddit.com/r/django/comments/1qr5mfp/what_resources_would_you_recommend_to_learn/">[comments]</a>

I’ve never worked in prod, I want to deploy and run real-world production apps on AWS, but I’m overwhelmed by the sheer number of services.
 My goal:
 Deploy Django/FastAPI APIs
 Use Postgres
 Handle background tasks
 Use cache like redis
 Store files
 Set up basic logging/monitoring
 Setup CDN
 What I’m looking for:
 A minimal, practical AWS stack I should focus on.
 Which services are must-learn vs safe to ignore early on
 Learning resources (courses, blogs, YouTube, hands-on repos) that are backend-dev focused, not DevOps-heavy
 For example: Is EC2 + RDS + S3 + IAM enough to start? Should I skip ECS/EKS/Lambda initially? What do Django teams actually use in production?
 I’d really appreciate advice from people running Django/FastAPI apps on AWS in real jobs.
    submitted by    /u/adamfloyd1506  
 [link]   [comments]

What resources would you recommend to learn Django/Fast API adjacent AWS?

<table> <tr><td> <a href="https://www.reddit.com/r/flask/comments/1qu77df/i_made_a_baby_names_web_app_using_flask_that/"> <img src="https://b.thumbs.redditmedia.com/6Tc22mh8-KvK-b79V15EacR9Z5gl-6lOuEa_FOlQQDg.jpg" alt="I made a baby names web app using Flask that includes group creation and tinder-style swiping. It also functions as a general US-based names database." title="I made a baby names web app using Flask that includes group creation and tinder-style swiping. It also functions as a general US-based names database." /> </a> </td><td> <div class="md">This project utilizes a MySQL DB for the core of the data, with a hosted Redis DB supporting the /explore endpoint (swiping). I am using <a href="http://pythonanywhere.com/">PythonAnywhere.com</a> for this, and have used them for many years with other projects. I recommend them. The idea for this project came from a friend who was looking for a baby names app, and couldn&#39;t quite find the right match. I was looking for a new coding project, so I jumped at the opportunity. The web app lets you create groups, invite folks to the group, and have a shared results view. You can also use it without a group, and/or use it solo outside of any groups you may be part of, as the swiping is context-based. The app also has a general search feature with each name having a general detail page. For the source data, I found that the Social Security Administration hosts a file with the first names from all applications, sorted by year, and nicely formatted, dating back to 1880. This does lag each year by about 3 months or so, making my DB only current through 2024 at this point in time. The data comes in year-labeled folders, with rows of info that look like this: &quot;Mary, F, 54301&quot; (name, gender, count). This is my only source of data, making it scoped to only the United States, and only back to 1880. Despite that limitation, there are still about 105k unique names, and just over 2 million datapoints (year, name, gender, count). The name meanings are AI-generated using gpt-4o-mini (as it&#39;s the cheapest for bulk batching). It took about 7 prompt iterations before I found a consistent result that passed my requirements and spot checks. Not a lot of names had a meaning generated under this final prompt (I think it was something like &lt;20%), so I made a semi-strict version for the remaining names, and then another softer version for the names that still passed through. I have included a voting/reporting system for the name meanings on each name&#39;s respective details page to allow for per-name feedback. This is my first time using Redis (I had never heard of it before starting this project), and it was super interesting learning how it works and how to implement it into the backend. The stricter filters would take 5-6 seconds to generate the results deck with SQL, and got cut down to ~1 second with Redis. There are still a few optimizations I&#39;m working on - if you go really strict with your filter, so that there&#39;s one or two results only, it can slog, but a patch for that is incoming this week. I have baked in support for country_codes if I ever do want to expand to pull data from other countries, but as this is a rather niche app, I&#39;m happy keeping it to just the US for now. I made the site live a couples weeks ago, and am looking for some feedback/ideas for additional features, as the bug-squashing has calmed down. If you do encounter any bugs please DM me, reply here, or use the contact link on the website if you&#39;re feeling fancy (it&#39;s just an email link). You can fully use the Search feature and the Top 10s page without an account. The rest of the swiping and group stuff is locked behind an account. Everything is 100% free to use, with no current paywall plans. There are also no ads at the moment. Thanks for taking a look! <a href="https://www.cubcards.com/">https://www.cubcards.com/</a> From the photos: <a href="https://www.cubcards.com/name/ruth">https://www.cubcards.com/name/ruth</a> <a href="https://www.cubcards.com/top-tens">https://www.cubcards.com/top-tens</a> </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/ndcheezit"> /u/ndcheezit </a> <a href="https://www.reddit.com/gallery/1qu77df">[link]</a> &#32; <a href="https://www.reddit.com/r/flask/comments/1qu77df/i_made_a_baby_names_web_app_using_flask_that/">[comments]</a> </td></tr></table>

This project utilizes a MySQL DB for the core of the data, with a hosted Redis DB supporting the /explore endpoint (swiping). I am using PythonAnywhere.com for this, and have used them for many years with other projects. I recommend them.
 The idea for this project came from a friend who was looking for a baby names app, and couldn't quite find the right match. I was looking for a new coding project, so I jumped at the opportunity. The web app lets you create groups, invite folks to the group, and have a shared results view. You can also use it without a group, and/or use it solo outside of any groups you may be part of, as the swiping is context-based. The app also has a general search feature with each name having a general detail page.
 For the source data, I found that the Social Security Administration hosts a file with the first names from all applications, sorted by year, and nicely formatted, dating back to 1880. This does lag each year by about 3 months or so, making my DB only current through 2024 at this point in time. The data comes in year-labeled folders, with rows of info that look like this: "Mary, F, 54301" (name, gender, count). This is my only source of data, making it scoped to only the United States, and only back to 1880. Despite that limitation, there are still about 105k unique names, and just over 2 million datapoints (year, name, gender, count).
 The name meanings are AI-generated using gpt-4o-mini (as it's the cheapest for bulk batching). It took about 7 prompt iterations before I found a consistent result that passed my requirements and spot checks. Not a lot of names had a meaning generated under this final prompt (I think it was something like <20%), so I made a semi-strict version for the remaining names, and then another softer version for the names that still passed through. I have included a voting/reporting system for the name meanings on each name's respective details page to allow for per-name feedback. 
 This is my first time using Redis (I had never heard of it before starting this project), and it was super interesting learning how it works and how to implement it into the backend. The stricter filters would take 5-6 seconds to generate the results deck with SQL, and got cut down to ~1 second with Redis. There are still a few optimizations I'm working on - if you go really strict with your filter, so that there's one or two results only, it can slog, but a patch for that is incoming this week.
 I have baked in support for country_codes if I ever do want to expand to pull data from other countries, but as this is a rather niche app, I'm happy keeping it to just the US for now.
 I made the site live a couples weeks ago, and am looking for some feedback/ideas for additional features, as the bug-squashing has calmed down.
 If you do encounter any bugs please DM me, reply here, or use the contact link on the website if you're feeling fancy (it's just an email link).
 You can fully use the Search feature and the Top 10s page without an account. The rest of the swiping and group stuff is locked behind an account. Everything is 100% free to use, with no current paywall plans. There are also no ads at the moment.
 Thanks for taking a look!
 https://www.cubcards.com/
 From the photos:
 https://www.cubcards.com/name/ruth
 https://www.cubcards.com/top-tens
 submitted by /u/ndcheezit 
 [link] [comments]

I made a baby names web app using Flask that includes group creation and tinder-style swiping. It also functions as a general US-based names database.

<div class="md">Hello there. I’m a Python beginner and I just transitioned to learning Flask. Are there any sites I can download free CSS templates for lightweight projects I’m working? Thank you </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/GunzOnReddit"> /u/GunzOnReddit </a> <a href="https://www.reddit.com/r/flask/comments/1qwz47x/flask_beginner/">[link]</a> &#32; <a href="https://www.reddit.com/r/flask/comments/1qwz47x/flask_beginner/">[comments]</a>

Hello there. I’m a Python beginner and I just transitioned to learning Flask. Are there any sites I can download free CSS templates for lightweight projects I’m working? Thank you
    submitted by    /u/GunzOnReddit  
 [link]   [comments]

Flask beginner

&#32; submitted by &#32; <a href="https://www.reddit.com/user/StrikingImage167"> /u/StrikingImage167 </a> <a href="https://www.researchgate.net/publication/392329827_Hybrid_System_for_Verifying_the_Credibility_of_Information_Sources_An_Ontology_ISBN_978-1-0699904-3-3_DOI_1013140RG222292647680">[link]</a> &#32; <a href="https://www.reddit.com/r/flask/comments/1qr6u9o/my_neurosymbolic_ontology_fact_checking_system/">[comments]</a>

submitted by    /u/StrikingImage167  
 [link]   [comments]

My neurosymbolic ontology fact checking system with flask backend

<div class="md">I’ve been working on a free tool that helps generate OpenAPI specs without a lot of manual boilerplate. The goal is to make it easier to: <ul> <li>Quickly generate a valid OpenAPI spec.</li> <li>Keep specs consistent and readable.</li> <li>Avoid hand-editing YAML/JSON for every change.</li> <li>Constraint-mining.</li> </ul> Here’s a short demo / link: 👉 [<a href="https://github.com/driftlint/driftlint-demo/pull/2">Github - Demo</a>] It’s still early, so I’m mainly looking for feedback: <ul> <li>Does this solve a real pain point for you?</li> <li>Anything confusing or missing?</li> <li>How does it compare to your current workflow?</li> </ul> Just trying to make something genuinely useful for devs who deal with APIs regularly. 🙏 </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/No_Bit_1894"> /u/No_Bit_1894 </a> <a href="https://www.reddit.com/r/flask/comments/1qr38wy/i_made_a_free_tool_to_generate_openapi_specs/">[link]</a> &#32; <a href="https://www.reddit.com/r/flask/comments/1qr38wy/i_made_a_free_tool_to_generate_openapi_specs/">[comments]</a>

I’ve been working on a free tool that helps generate OpenAPI specs without a lot of manual boilerplate.
 The goal is to make it easier to:
  
Quickly generate a valid OpenAPI spec.
 Keep specs consistent and readable.
 Avoid hand-editing YAML/JSON for every change.
 Constraint-mining.
  
Here’s a short demo / link:
 👉 [Github - Demo]
 It’s still early, so I’m mainly looking for feedback:
  
Does this solve a real pain point for you?
 Anything confusing or missing?
 How does it compare to your current workflow?
  
Just trying to make something genuinely useful for devs who deal with APIs regularly. 🙏
    submitted by    /u/No_Bit_1894  
 [link]   [comments]

I made a free tool to generate OpenAPI specs — feedback welcome

<div class="md">App I have runs well. Trying to get the app to have an install option for users. All files in the static folder report 404&#39;s (manifest, icons, sw.js). each screen prompt results in a delay ultimately the app runs with no install option. This is my first attempt to included this feature in an app. what information should I provide to help trouble shoot this issue and how should I provide it? Note that all the paths are valid. </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/Crafty-Juggernaut-10"> /u/Crafty-Juggernaut-10 </a> <a href="https://www.reddit.com/r/flask/comments/1qs4qxy/pwa_related_404s/">[link]</a> &#32; <a href="https://www.reddit.com/r/flask/comments/1qs4qxy/pwa_related_404s/">[comments]</a>

App I have runs well. Trying to get the app to have an install option for users. All files in the static folder report 404's (manifest, icons, sw.js). each screen prompt results in a delay ultimately the app runs with no install option. This is my first attempt to included this feature in an app. what information should I provide to help trouble shoot this issue and how should I provide it? Note that all the paths are valid.
    submitted by    /u/Crafty-Juggernaut-10  
 [link]   [comments]

PWA related 404's

<table> <tr><td> <a href="https://www.reddit.com/r/flask/comments/1qsau08/my_fact_checking_system_package_is_now_available/"> <img src="https://preview.redd.it/omc9kdseeqgg1.jpeg?width=640&amp;crop=smart&amp;auto=webp&amp;s=9a04311d087012ffaef2bbbafccccdea4bce36b4" alt="My fact checking system package is now available https://pypi.org/project/syscred/" title="My fact checking system package is now available https://pypi.org/project/syscred/" /> </a> </td><td> &#32; submitted by &#32; <a href="https://www.reddit.com/user/StrikingImage167"> /u/StrikingImage167 </a> <a href="https://i.redd.it/omc9kdseeqgg1.jpeg">[link]</a> &#32; <a href="https://www.reddit.com/r/flask/comments/1qsau08/my_fact_checking_system_package_is_now_available/">[comments]</a> </td></tr></table>

My fact checking system package is now available https://pypi.org/project/syscred/

<div class="md">Preferably one, long youtube video that shows how to create a website in django, so i can follow it and create something of my own? Maybe a series of videos? </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/CaptainFlint9203"> /u/CaptainFlint9203 </a> <a href="https://www.reddit.com/r/djangolearning/comments/1qsu2qm/any_tutorial_that_shows_from_start_to_finish_how/">[link]</a> &#32; <a href="https://www.reddit.com/r/djangolearning/comments/1qsu2qm/any_tutorial_that_shows_from_start_to_finish_how/">[comments]</a>

Preferably one, long youtube video that shows how to create a website in django, so i can follow it and create something of my own? Maybe a series of videos?
    submitted by    /u/CaptainFlint9203  
 [link]   [comments]

Any tutorial that shows from start to finish how to make django web app?

&#32; submitted by &#32; <a href="https://www.reddit.com/user/No_Inevitable9712"> /u/No_Inevitable9712 </a> <a href="/r/learnpython/comments/1qtn1n3/how_to_dynamically_add_content_to_pdf/">[link]</a> &#32; <a href="https://www.reddit.com/r/djangolearning/comments/1qtn2zj/how_to_dynamically_add_content_to_pdf/">[comments]</a>

submitted by    /u/No_Inevitable9712  
 [link]   [comments]

How to dynamically add content to pdf.

<div class="md">I just got a book from the Library named &quot; into to python for computer science and data science&quot; anyone have any idea about this book should I learn python using this book.I am completely beginner into this field I just wanna learn python with a strong base. </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/Fearless-Rub-8397"> /u/Fearless-Rub-8397 </a> <a href="https://www.reddit.com/r/djangolearning/comments/1qtncwx/into_to_python_for_computer_science_and_data/">[link]</a> &#32; <a href="https://www.reddit.com/r/djangolearning/comments/1qtncwx/into_to_python_for_computer_science_and_data/">[comments]</a>

I just got a book from the Library named " into to python for computer science and data science" anyone have any idea about this book should I learn python using this book.I am completely beginner into this field I just wanna learn python with a strong base.
    submitted by    /u/Fearless-Rub-8397  
 [link]   [comments]

INTO TO PYTHON FOR COMPUTER SCIENCE AND DATA SCIENCE by PAUL DEITEL

<table> <tr><td> <a href="https://www.reddit.com/r/FastAPI/comments/1qs56pf/small_complexity_comparison_django_vs_fastapi/"> <img src="https://b.thumbs.redditmedia.com/k6T_N-vQnHIwxABQB8mpaEBBo3eLvGt6HaxzjcV54Mo.jpg" alt="Small complexity comparison Django vs. FastAPI" title="Small complexity comparison Django vs. FastAPI" /> </a> </td><td> <div class="md">Explanation This visualizations work by assigning every file a dot. <ul> <li>Green = Low Complexity</li> <li>Red = High Complexity</li> </ul> Complexity is defined as Cyclomatic complexity (McCabe). The first image is Fast APIs dependency graph. Very structured and modularized. Very few Complex files and lower rates of connection between files. Most of the files are tests and tutorials. The second image shows Djangos graph: Much more interconnected and less modularized. More high complexity files but again most of the codebase is related to testing. Hope you found the comparison as interesting as I did! </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/swupel_"> /u/swupel_ </a> <a href="https://ast-visualizer.com">[link]</a> &#32; <a href="https://www.reddit.com/r/FastAPI/comments/1qs56pf/small_complexity_comparison_django_vs_fastapi/">[comments]</a> </td></tr></table>

Explanation
 This visualizations work by assigning every file a dot.
  
Green = Low Complexity
 Red = High Complexity
  
Complexity is defined as Cyclomatic complexity (McCabe).
 The first image is Fast APIs dependency graph.
 Very structured and modularized. Very few Complex files and lower rates of connection between files. Most of the files are tests and tutorials.
 The second image shows Djangos graph:
 Much more interconnected and less modularized. More high complexity files but again most of the codebase is related to testing. 
 Hope you found the comparison as interesting as I did!
    submitted by    /u/swupel_  
 [link]   [comments]

Small complexity comparison Django vs. FastAPI

<div class="md">Hey everyone, I’m exploring different logging options for my projects (fastapi RESTful backend and I’d love some input. So far I’ve monitored the situations as following: <ul> <li><code>fastapi dev</code> and <code>fastapi run</code> commands display logs in stdout</li> <li><code>fastapi run --workers 4</code> command doesn&#39;t display logs in stoud</li> </ul> Is this intended behavior? Am i supposed to get logs in stdout and schedule a task in the server running Docker or should I handle my logs internally? I’m mostly interested in: <ul> <li>Clean logs (readability really matters)</li> <li>Ease of use / developer experience</li> <li>Flexibility for future scaling (e.g., larger apps, integrations)</li> </ul> Is there a best practice here for logging in production that I should know about, feels like it since stdout is disabled on prod? Is there some hidden gem I should check out instead? Thanks in advance! </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/xTaiirox"> /u/xTaiirox </a> <a href="https://www.reddit.com/r/FastAPI/comments/1qt97fp/advice_on_logging_in_production/">[link]</a> &#32; <a href="https://www.reddit.com/r/FastAPI/comments/1qt97fp/advice_on_logging_in_production/">[comments]</a>

Hey everyone,
 I’m exploring different logging options for my projects (fastapi RESTful backend and I’d love some input.
 So far I’ve monitored the situations as following:
  
fastapi dev and fastapi run commands display logs in stdout
 fastapi run --workers 4 command doesn't display logs in stoud
  
Is this intended behavior? Am i supposed to get logs in stdout and schedule a task in the server running Docker or should I handle my logs internally?
 I’m mostly interested in:
  
Clean logs (readability really matters)
 Ease of use / developer experience
 Flexibility for future scaling (e.g., larger apps, integrations)
  
Is there a best practice here for logging in production that I should know about, feels like it since stdout is disabled on prod?
 Is there some hidden gem I should check out instead?
 Thanks in advance!
    submitted by    /u/xTaiirox  
 [link]   [comments]

Advice on logging in production

<div class="md">I’m currently learning Python backend development and focusing on FastAPI. So far I’ve been working through things like API design, async concepts, authentication, database integration, and general backend structure. Still early in the journey, still figuring out best practices, and still building small projects to understand how everything fits together. I wanted to hear from people who’ve already gone down this path or are currently on it </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/irritatednishant"> /u/irritatednishant </a> <a href="https://www.reddit.com/r/FastAPI/comments/1qs4mvb/looking_for_people_learning_python_backend_fastapi/">[link]</a> &#32; <a href="https://www.reddit.com/r/FastAPI/comments/1qs4mvb/looking_for_people_learning_python_backend_fastapi/">[comments]</a>

I’m currently learning Python backend development and focusing on FastAPI.
 So far I’ve been working through things like API design, async concepts, authentication, database integration, and general backend structure. Still early in the journey, still figuring out best practices, and still building small projects to understand how everything fits together.
 I wanted to hear from people who’ve already gone down this path or are currently on it
    submitted by    /u/irritatednishant  
 [link]   [comments]

Looking for people learning Python backend (FastAPI) –

<div class="md">I wanted to share a library we&#39;ve been using to secure our endpoints in our SaaS startup: <a href="https://github.com/cleanenergyexchange/fastapi-zitadel-auth"><code>fastapi-zitadel-auth</code></a> For those unfamiliar, Zitadel is an open source identity management solution built with Go and NextJS. Think open source like KeyCloak and &quot;easy&quot; like Auth0 with multi-tenancy (disclaimer: not affiliated with Zitadel at all), enterprise-ready which was important to us as clients need to integrate their own IdP (e.g. Entra and what not). When we started we did not find a suitable library so we built our own. It handles JWT validation via JWKS (Zitadel implements Introspection Calls as a default but this would slow down our Fast API). There&#39;s built-in Swagger UI support too, and RBAC. Basic usage is simple: <pre><code>from fastapi_zitadel_auth import ZitadelAuth auth = ZitadelAuth( issuer_url=&quot;https://your-instance.zitadel.cloud&quot;, project_id=&quot;...&quot;, app_client_id=&quot;...&quot; ) </code></pre> then use this dependency in the routes. source code: <a href="https://github.com/cleanenergyexchange/fastapi-zitadel-auth">https://github.com/cleanenergyexchange/fastapi-zitadel-auth</a> (which links to the more complete documentation). Let me know what you think. </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/dfhsr"> /u/dfhsr </a> <a href="https://www.reddit.com/r/FastAPI/comments/1qr5z7c/built_a_zitadel_auth_library_for_fastapi_to/">[link]</a> &#32; <a href="https://www.reddit.com/r/FastAPI/comments/1qr5z7c/built_a_zitadel_auth_library_for_fastapi_to/">[comments]</a>

I wanted to share a library we've been using to secure our endpoints in our SaaS startup: fastapi-zitadel-auth
 For those unfamiliar, Zitadel is an open source identity management solution built with Go and NextJS. Think open source like KeyCloak and "easy" like Auth0 with multi-tenancy (disclaimer: not affiliated with Zitadel at all), enterprise-ready which was important to us as clients need to integrate their own IdP (e.g. Entra and what not).
 When we started we did not find a suitable library so we built our own. It handles JWT validation via JWKS (Zitadel implements Introspection Calls as a default but this would slow down our Fast API). There's built-in Swagger UI support too, and RBAC.
 Basic usage is simple:
 from fastapi_zitadel_auth import ZitadelAuth auth = ZitadelAuth( issuer_url="https://your-instance.zitadel.cloud", project_id="...", app_client_id="..." ) 
 then use this dependency in the routes. 
 source code: https://github.com/cleanenergyexchange/fastapi-zitadel-auth (which links to the more complete documentation).
 Let me know what you think.
    submitted by    /u/dfhsr  
 [link]   [comments]

Built a Zitadel auth library for FastAPI to protect our endpoints with OAuth2/OIDC

<div class="md">Good day everyone, I currently deployed a FastAPI app with gunicorn with SQLModel/SQLAlchemy using asyncpg driver but I keep running in the issue when I try querying the postgres database via the API. I get a runtime error alert on sentry with the message: <pre><code>sqlalchemy.pool.impl.AsyncAdaptedQueuePool Exception terminating connection &lt;AdaptedConnection &lt;asyncpg.connection.Connection object at 0x7f18c856f2f0&gt;&gt; Event loop is closed </code></pre> Note I am running 4 workers with gunicorn. Here is my gunicorn config but I had to revert to 1 worker just to fix the issue with asyncpg, <pre><code>from dataclasses import asdict, dataclass from core.logging import configure_logging from fastapi import FastAPI from gunicorn.app.base import BaseApplication class GunicornApplication(BaseApplication): &quot;&quot;&quot; Custom `Gunicorn` application to run the FastAPI app with specific configurations. &quot;&quot;&quot; def __init__(self, app, options=None): self.options = options or {} self.application = app super().__init__() def load_config(self): config = {key: value for key, value in self.options.items() if key in self.cfg.settings and value is not None} for key, value in config.items(): self.cfg.set(key.lower(), value) def load(self): return self.application def post_fork(self, server, worker) : # noqa: ARG001 &quot;&quot;&quot; Called in the worker process after fork to (re)configure logging. &quot;&quot;&quot; try: configure_logging() server.log.info(&quot;Reconfigured structured logging in worker&quot;) except Exception as e: # pragma: no cover try: server.log.exception(f&quot;Failed to reconfigure logging in worker: {e}&quot;) except Exception: pass @dataclass class GunicornOptions: &quot;&quot;&quot; Configuration options for Gunicorn. Attributes: bind (str): The address and port to bind the server to. workers (int): The number of worker processes to spawn. worker_class (str): The type of worker class to use. loglevel (str): The logging level for Gunicorn. keepalive (int): The number of seconds to wait for the next request on a Keep-Alive HTTP connection. asgi_loop (str): The ASGI event loop implementation to use. max_requests (int): The maximum number of requests a worker will process before restarting. max_requests_jitter (int): The maximum jitter to add to the max_requests setting. preload_app (bool): Whether to preload the application before forking worker processes. &quot;&quot;&quot; bind: str workers: int worker_class: str loglevel: str keepalive: int = 5 asgi_loop: str = &quot;uvloop&quot; max_requests: int = 1000 max_requests_jitter: int = 50 preload_app: bool = True def run_with_gunicorn(app: FastAPI, options: GunicornOptions): &quot;&quot;&quot; Run the given FastAPI app with Gunicorn. Args: app (FastAPI): The FastAPI application instance to run. options (GunicornOptions): Configuration options for Gunicorn. &quot;&quot;&quot; configure_logging() options_stored = options if options_stored.workers == 1: # NOTE (Daniel): You automatically set the workers to 1 when you detect asyncpg driver usage from the caller side of run_with_gunicorn # max_requests and max_requests_jitter are set to 0 when using a single worker to avoid issues with asyncpg connections. options_stored = GunicornOptions(**{**asdict(options_stored), &quot;max_requests&quot;: 0, &quot;max_requests_jitter&quot;: 0}) options_as_dict = asdict(options_stored) GunicornApplication(app, options_as_dict).run() </code></pre> Has anyone run into this issue before and how did you fix it? Any help would be appreciated. </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/Danny_Brai"> /u/Danny_Brai </a> <a href="https://www.reddit.com/r/FastAPI/comments/1qvmfyd/gunicorn_deployment_with_fastapi/">[link]</a> &#32; <a href="https://www.reddit.com/r/FastAPI/comments/1qvmfyd/gunicorn_deployment_with_fastapi/">[comments]</a>

Good day everyone, I currently deployed a FastAPI app with gunicorn with SQLModel/SQLAlchemy using asyncpg driver but I keep running in the issue when I try querying the postgres database via the API. I get a runtime error alert on sentry with the message:
 sqlalchemy.pool.impl.AsyncAdaptedQueuePool Exception terminating connection <AdaptedConnection <asyncpg.connection.Connection object at 0x7f18c856f2f0>> Event loop is closed 
 Note I am running 4 workers with gunicorn. Here is my gunicorn config but I had to revert to 1 worker just to fix the issue with asyncpg,
 from dataclasses import asdict, dataclass from core.logging import configure_logging from fastapi import FastAPI from gunicorn.app.base import BaseApplication class GunicornApplication(BaseApplication): """ Custom `Gunicorn` application to run the FastAPI app with specific configurations. """ def __init__(self, app, options=None): self.options = options or {} self.application = app super().__init__() def load_config(self): config = {key: value for key, value in self.options.items() if key in self.cfg.settings and value is not None} for key, value in config.items(): self.cfg.set(key.lower(), value) def load(self): return self.application def post_fork(self, server, worker) : # noqa: ARG001 """ Called in the worker process after fork to (re)configure logging. """ try: configure_logging() server.log.info("Reconfigured structured logging in worker") except Exception as e: # pragma: no cover try: server.log.exception(f"Failed to reconfigure logging in worker: {e}") except Exception: pass @dataclass class GunicornOptions: """ Configuration options for Gunicorn. Attributes: bind (str): The address and port to bind the server to. workers (int): The number of worker processes to spawn. worker_class (str): The type of worker class to use. loglevel (str): The logging level for Gunicorn. keepalive (int): The number of seconds to wait for the next request on a Keep-Alive HTTP connection. asgi_loop (str): The ASGI event loop implementation to use. max_requests (int): The maximum number of requests a worker will process before restarting. max_requests_jitter (int): The maximum jitter to add to the max_requests setting. preload_app (bool): Whether to preload the application before forking worker processes. """ bind: str workers: int worker_class: str loglevel: str keepalive: int = 5 asgi_loop: str = "uvloop" max_requests: int = 1000 max_requests_jitter: int = 50 preload_app: bool = True def run_with_gunicorn(app: FastAPI, options: GunicornOptions): """ Run the given FastAPI app with Gunicorn. Args: app (FastAPI): The FastAPI application instance to run. options (GunicornOptions): Configuration options for Gunicorn. """ configure_logging() options_stored = options if options_stored.workers == 1: # NOTE (Daniel): You automatically set the workers to 1 when you detect asyncpg driver usage from the caller side of run_with_gunicorn # max_requests and max_requests_jitter are set to 0 when using a single worker to avoid issues with asyncpg connections. options_stored = GunicornOptions(**{**asdict(options_stored), "max_requests": 0, "max_requests_jitter": 0}) options_as_dict = asdict(options_stored) GunicornApplication(app, options_as_dict).run() 
 Has anyone run into this issue before and how did you fix it? Any help would be appreciated.
 submitted by /u/Danny_Brai 
 [link] [comments]

Gunicorn deployment with FastAPI

<table> <tr><td> <a href="https://www.reddit.com/r/FastAPI/comments/1qs9y9h/can_i_get_feedback_on_my_first_full_backend/"> <img src="https://external-preview.redd.it/lJkK3L9VVMvJAUfSrRsItHc5XptD65aucmqFl098ePs.png?width=640&amp;crop=smart&amp;auto=webp&amp;s=2dfd5a040d8d0fd4699d8e77110d29c46f934f60" alt="Can I get feedback on my first full backend project" title="Can I get feedback on my first full backend project" /> </a> </td><td> &#32; submitted by &#32; <a href="https://www.reddit.com/user/MohamedMotaz"> /u/MohamedMotaz </a> <a href="https://github.com/ma7amed77/e-commerce-backend">[link]</a> &#32; <a href="https://www.reddit.com/r/FastAPI/comments/1qs9y9h/can_i_get_feedback_on_my_first_full_backend/">[comments]</a> </td></tr></table>

submitted by    /u/MohamedMotaz  
 [link]   [comments]

Can I get feedback on my first full backend project

<div class="md">If you are a network engineer want to implement a TACACS+ server, try my open source project at: <a href="https://github.com/thangphan205/tacacs-ng-ui">https://github.com/thangphan205/tacacs-ng-ui</a> tacacs-ng-ui based on <a href="https://github.com/fastapi/full-stack-fastapi-template">https://github.com/fastapi/full-stack-fastapi-template</a> </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/thangphan205"> /u/thangphan205 </a> <a href="https://www.reddit.com/r/FastAPI/comments/1quhru2/network_aaa_tacacs_server_ui_based_on/">[link]</a> &#32; <a href="https://www.reddit.com/r/FastAPI/comments/1quhru2/network_aaa_tacacs_server_ui_based_on/">[comments]</a>

If you are a network engineer want to implement a TACACS+ server, try my open source project at: https://github.com/thangphan205/tacacs-ng-ui
 tacacs-ng-ui based on https://github.com/fastapi/full-stack-fastapi-template 
    submitted by    /u/thangphan205  
 [link]   [comments]

Network AAA - TACACS+ Server UI based on full-stack-fastapi-template

<div class="md">Hey everyone, I’ve been working on a project to help AI agents and e-commerce stores measure sustainability. I realized most &quot;carbon calculators&quot; are black boxes or require enterprise contracts. So I built a transparent API that calculates CO2, logistics impact, and even flags EU CBAM compliance based on product weight and materials. The Stack: <ul> <li>Backend: Python / FastAPI</li> <li>Host: Railway</li> <li>Logic: ISO-based coefficients for materials + Haversine formula for logistics.</li> </ul> I created a GitHub repo with examples on how to use it with Shopify or LangChain agents: 🔗 <a href="https://github.com/autozbudoucnosti/product-sustainability-examples/tree/main">https://github.com/autozbudoucnosti/product-sustainability-examples/tree/main</a> It’s free to use for developers (up to 100 requests/month). I’d love feedback on the response structure—specifically if the &quot;breakdown&quot; fields are useful for those building AI agents. Thanks! </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/AutoZBudoucnosti"> /u/AutoZBudoucnosti </a> <a href="https://www.reddit.com/r/FastAPI/comments/1qw0ly8/i_built_a_python_tool_to_calculate_carbon/">[link]</a> &#32; <a href="https://www.reddit.com/r/FastAPI/comments/1qw0ly8/i_built_a_python_tool_to_calculate_carbon/">[comments]</a>

Hey everyone,
 I’ve been working on a project to help AI agents and e-commerce stores measure sustainability.
 I realized most "carbon calculators" are black boxes or require enterprise contracts. So I built a transparent API that calculates CO2, logistics impact, and even flags EU CBAM compliance based on product weight and materials.
 The Stack:
  
Backend: Python / FastAPI
 Host: Railway
 Logic: ISO-based coefficients for materials + Haversine formula for logistics.
  
I created a GitHub repo with examples on how to use it with Shopify or LangChain agents:
 🔗 https://github.com/autozbudoucnosti/product-sustainability-examples/tree/main
 It’s free to use for developers (up to 100 requests/month).
 I’d love feedback on the response structure—specifically if the "breakdown" fields are useful for those building AI agents.
 Thanks!
    submitted by    /u/AutoZBudoucnosti  
 [link]   [comments]

I built a Python tool to calculate carbon footprints for Shopify products (Free API)

&#32; submitted by &#32; <a href="https://www.reddit.com/user/Suitable-Tax9934"> /u/Suitable-Tax9934 </a> <a href="/r/Backend/comments/1qt55r6/backend_development_in_2026/">[link]</a> &#32; <a href="https://www.reddit.com/r/FastAPI/comments/1qt56xj/backend_development_in_2026/">[comments]</a>

submitted by    /u/Suitable-Tax9934  
 [link]   [comments]

Backend development in 2026

&#32; submitted by &#32; <a href="https://www.reddit.com/user/rustybladez23"> /u/rustybladez23 </a> <a href="/r/Backend/comments/1qr5k5w/mock_apis_are_getting_into_my_nerves/">[link]</a> &#32; <a href="https://www.reddit.com/r/FastAPI/comments/1qr5lk2/sharing_here_since_i_use_fastapi_for_my_backend/">[comments]</a>

submitted by    /u/rustybladez23  
 [link]   [comments]

Sharing here since I use FastAPI for my backend work

&#32; submitted by &#32; <a href="https://www.reddit.com/user/Shorty52249"> /u/Shorty52249 </a> <a href="/r/developersIndia/comments/1qwhphq/for_a_developer_in_india_with_12_years_experience/">[link]</a> &#32; <a href="https://www.reddit.com/r/FastAPI/comments/1qwhs2j/for_a_developer_in_india_with_12_years_experience/">[comments]</a>

submitted by    /u/Shorty52249  
 [link]   [comments]

Hello, Python

Python Jobs 💼