<div class="md">I&#39;m asking if anyone knows if there&#39;s any R.O.I. making E-commerce sites because most people are going straight to Amazon to buy what they need, leaving all the independent E-commerce sites alone. Is this going to be a long-term trend ? Back in the day, I used to be an Adobe Flash/Flex developer and I have seen the internet change drastically from what it used to be like. I&#39;ve been learning Django for about a year now, and I&#39;ve become very proficient at it. I&#39;m afraid there is no market left for E-commerce because of Amazon hogging all the customers. Does anyone else have an opinion on this matter ? </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/Correct_Car1985"> /u/Correct_Car1985 </a> <a href="https://www.reddit.com/r/djangolearning/comments/1qjmduc/is_it_pointless_to_make_ecommerce_sites_these_days/">[link]</a> &#32; <a href="https://www.reddit.com/r/djangolearning/comments/1qjmduc/is_it_pointless_to_make_ecommerce_sites_these_days/">[comments]</a>

I'm asking if anyone knows if there's any R.O.I. making E-commerce sites because most people are going straight to Amazon to buy what they need, leaving all the independent E-commerce sites alone. Is this going to be a long-term trend ?
 Back in the day, I used to be an Adobe Flash/Flex developer and I have seen the internet change drastically from what it used to be like.
 I've been learning Django for about a year now, and I've become very proficient at it. I'm afraid there is no market left for E-commerce because of Amazon hogging all the customers. 
 Does anyone else have an opinion on this matter ?
    submitted by    /u/Correct_Car1985  
 [link]   [comments]

Is it pointless to make E-commerce sites these days ?

<div class="md">My project has some geographic data and is backed by a postgis container and displays in Leaflet maps. Currently, I have a class that stores a PointField geometry, but I want to expand my capabilities to store polygons as well so I can outline a region. Currently, I have a structure like: <pre><code>class PointOfInterest(models.Model): foo = models.CharField bar = models.TextField ref = models.ForeignKey(&quot;Parent&quot;, on_delete=models.CASCADE) location = gis_models&gt;pointField(srid=4326) </code></pre> I got advice to update the model to having a base class that Points and Areas inherit from, rather than trying to add a <code>multipolygon</code> field to the existing class, so that I would wind up with something like: <pre><code>class Interests(models.Model): foo = models.CharField bar = models.TextField ref = models.ForeignKey(&quot;Parent&quot;, on_delete=models.CASCADE) geometry = gis_models.GeometryField(srid=4326) </code></pre> with properties to return the longitude and latitude if the geometry type is a point. and have inheriting classes <pre><code>class PointOfInterest(Interests): def save(self, *args, **hwargs): if self.geometry and self.geometry.geom_type != &#39;Point&#39;: </code></pre> --error handling-- <pre><code>class AreaOfInterest(Interests): def save(self, *args, **hwargs): if self.geometry and self.geometry.geom_type != &#39;MultiPolygon&#39;: </code></pre> --error handling-- The issue I&#39;m having is this: while trying to update my models (which do currently contain test data), I get the usual warning making the migration, stating <code>It is impossible to add a non-nullable field &#39;interests_ptr&#39; to pointofinterest without specifying a default. This is because the database needs something to populate existing rows.</code> <code>Please select a fix:</code> <code>1) Provide a one-off default now (will be set on all existing rows with a null value for this column)</code> <code>2) Quit and manually define a default value in models.py.</code> Adding a placeholder value failed because this field is a primary key and so it&#39;s creating duplication. At the moment I&#39;ve backed out the change, restored the database from pre-migration backup, and reassessing. My question is threefold: <ol> <li>Is this even the right approach? This is a purely for-fun-and-learning project so my investment in getting it right is focused on good development habits.</li> <li>In general, how could I manually make the migration so that a pkey field is populated in a way that won&#39;t bork the database?</li> <li>In this specific case, is it more reasonable to just nuke the test data and recreate it?</li> </ol> </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/BestCaseSurvival"> /u/BestCaseSurvival </a> <a href="https://www.reddit.com/r/djangolearning/comments/1qh9tku/updating_an_existing_model_having_trouble_with/">[link]</a> &#32; <a href="https://www.reddit.com/r/djangolearning/comments/1qh9tku/updating_an_existing_model_having_trouble_with/">[comments]</a>

My project has some geographic data and is backed by a postgis container and displays in Leaflet maps. Currently, I have a class that stores a PointField geometry, but I want to expand my capabilities to store polygons as well so I can outline a region.
 Currently, I have a structure like:
 class PointOfInterest(models.Model): foo = models.CharField bar = models.TextField ref = models.ForeignKey("Parent", on_delete=models.CASCADE) location = gis_models>pointField(srid=4326) 
 I got advice to update the model to having a base class that Points and Areas inherit from, rather than trying to add a multipolygon field to the existing class, so that I would wind up with something like:
 class Interests(models.Model): foo = models.CharField bar = models.TextField ref = models.ForeignKey("Parent", on_delete=models.CASCADE) geometry = gis_models.GeometryField(srid=4326) 
 with properties to return the longitude and latitude if the geometry type is a point.
 and have inheriting classes
 class PointOfInterest(Interests): def save(self, *args, **hwargs): if self.geometry and self.geometry.geom_type != 'Point': 
 --error handling--
 class AreaOfInterest(Interests): def save(self, *args, **hwargs): if self.geometry and self.geometry.geom_type != 'MultiPolygon': 
 --error handling--
 The issue I'm having is this: while trying to update my models (which do currently contain test data), I get the usual warning making the migration, stating
 It is impossible to add a non-nullable field 'interests_ptr' to pointofinterest without specifying a default. This is because the database needs something to populate existing rows.
 Please select a fix:
 1) Provide a one-off default now (will be set on all existing rows with a null value for this column)
 2) Quit and manually define a default value in models.py.
 Adding a placeholder value failed because this field is a primary key and so it's creating duplication. At the moment I've backed out the change, restored the database from pre-migration backup, and reassessing. My question is threefold:
  
Is this even the right approach? This is a purely for-fun-and-learning project so my investment in getting it right is focused on good development habits.
 In general, how could I manually make the migration so that a pkey field is populated in a way that won't bork the database?
 In this specific case, is it more reasonable to just nuke the test data and recreate it?
  
   submitted by    /u/BestCaseSurvival  
 [link]   [comments]

Updating an existing model, having trouble with migration.

&#32; submitted by &#32; <a href="https://www.reddit.com/user/Lazy_Equipment6485"> /u/Lazy_Equipment6485 </a> <a href="https://youtu.be/99qZ-y8Nhx0?si=Dw3OihZU0YlZCBBS">[link]</a> &#32; <a href="https://www.reddit.com/r/djangolearning/comments/1qlskqs/customizing_djangoallauth_custom_signup_forms_and/">[comments]</a>

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

Customizing django-allauth - custom signup forms and logic!

<div class="md">In Modelforms, I pre-fetched a selection of objects but I have to create queryset to pass them into my field. <pre><code>feature_ids = [x.id for x in Feature.objects.filter(...)] self.fields[&quot;feature&quot;].queryset = Feature.objects.filter(id__in=feature_ids) </code></pre> I&#39;m doing this in a couple of different places causing quite performance hit. Is there a way to improve performance? Either by caching or passing a list of objects directly instead of a queryset? </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/19c766e1-22b1-40ce"> /u/19c766e1-22b1-40ce </a> <a href="https://www.reddit.com/r/djangolearning/comments/1qkr30o/cache_querysets_in_modelforms/">[link]</a> &#32; <a href="https://www.reddit.com/r/djangolearning/comments/1qkr30o/cache_querysets_in_modelforms/">[comments]</a>

In Modelforms, I pre-fetched a selection of objects but I have to create queryset to pass them into my field.
 feature_ids = [x.id for x in Feature.objects.filter(...)] self.fields["feature"].queryset = Feature.objects.filter(id__in=feature_ids) 
 I'm doing this in a couple of different places causing quite performance hit. Is there a way to improve performance? Either by caching or passing a list of objects directly instead of a queryset?
    submitted by    /u/19c766e1-22b1-40ce  
 [link]   [comments]

Cache querysets in Modelforms?

&#32; submitted by &#32; <a href="https://www.reddit.com/user/Abhish0210"> /u/Abhish0210 </a> <a href="/r/django/comments/1qlxd6h/looking_for_feedback_on_my_first_library_for/">[link]</a> &#32; <a href="https://www.reddit.com/r/djangolearning/comments/1qlxdsm/looking_for_feedback_on_my_first_library_for/">[comments]</a>

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

Looking for feedback on my first library for Django (WHOOP API integration)

<div class="md">This is where Python finally feels real. We build a real-world e-commerce price tracker using: ✔️ Modern Python ✔️ Real APIs ✔️ Async code ✔️ Clean project structure 🧠 Assignment (Very Important – Do This) Recreate the entire project from the video without copying the code blindly. Then add these TWO features: 1️⃣ Search products by category name (e.g. show all products in “smartphones”) 2️⃣ Search products by product name (case-insensitive search) 👉points to remember: Keep the code clean Reuse existing functions Don’t break the project structure This is how you move from learning Python to thinking like a Python developer 💪🐍 </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/faisal95iqbal"> /u/faisal95iqbal </a> <a href="https://youtu.be/5S7GzW0dEjk">[link]</a> &#32; <a href="https://www.reddit.com/r/djangolearning/comments/1qgjbx3/lecture_3_just_uploaded_python_masterclass_part_3/">[comments]</a>

This is where Python finally feels real. We build a real-world e-commerce price tracker using: ✔️ Modern Python ✔️ Real APIs ✔️ Async code ✔️ Clean project structure
 🧠 Assignment (Very Important – Do This) Recreate the entire project from the video without copying the code blindly. Then add these TWO features: 1️⃣ Search products by category name (e.g. show all products in “smartphones”) 2️⃣ Search products by product name (case-insensitive search)
 👉points to remember: Keep the code clean Reuse existing functions Don’t break the project structure
 This is how you move from learning Python to thinking like a Python developer 💪🐍
    submitted by    /u/faisal95iqbal  
 [link]   [comments]

LECTURE 3: Just uploaded Python Masterclass – Part 3

<div class="md">Hey everyone. I&#39;m a backend dev writing code in Python FastAPI. I don&#39;t have much experience in frontend other than basic HTML/CSS/JS. I&#39;m exploring different frontend tools/frameworks for my backend. The first obvious answer is React/Nextjs. But I don&#39;t want to delve into that complexity. Other options I&#39;ve explored are HTMX, Reflex, Astro, Sveltekit, etc. I&#39;ll mainly use the frontend for doing UIs for the backend (because testing in Swagger feels dull sometimes), make MVPs, and participate in hackathons (where quick development matters) Which frontend would you recommend learning as a backend dev? </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/rustybladez23"> /u/rustybladez23 </a> <a href="https://www.reddit.com/r/FastAPI/comments/1qh4cha/what_frontend_to_use_with_a_fastapi_backend/">[link]</a> &#32; <a href="https://www.reddit.com/r/FastAPI/comments/1qh4cha/what_frontend_to_use_with_a_fastapi_backend/">[comments]</a>

Hey everyone. I'm a backend dev writing code in Python FastAPI. I don't have much experience in frontend other than basic HTML/CSS/JS.
 I'm exploring different frontend tools/frameworks for my backend. The first obvious answer is React/Nextjs. But I don't want to delve into that complexity.
 Other options I've explored are HTMX, Reflex, Astro, Sveltekit, etc. I'll mainly use the frontend for doing UIs for the backend (because testing in Swagger feels dull sometimes), make MVPs, and participate in hackathons (where quick development matters)
 Which frontend would you recommend learning as a backend dev?
    submitted by    /u/rustybladez23  
 [link]   [comments]

What frontend to use with a FastAPI backend?

<table> <tr><td> <a href="https://www.reddit.com/r/FastAPI/comments/1qlrjlj/i_built_violit_a_highperformance_ui_framework/"> <img src="https://external-preview.redd.it/kDTwZaRcBksPAWmfsZQDrjsdM30B_6aY8NwrIxMomNw.png?width=640&amp;crop=smart&amp;auto=webp&amp;s=c00350b69f03d1aac2502d24e94091bb6faf3b18" alt="I built &quot;Violit&quot;: A High-Performance UI Framework powered by FastAPI &amp; Signals (O(1) reactivity without reruns)" title="I built &quot;Violit&quot;: A High-Performance UI Framework powered by FastAPI &amp; Signals (O(1) reactivity without reruns)" /> </a> </td><td> <div class="md">Hi everyone, I’m a huge fan of the FastAPI ecosystem. While I love FastAPI for its performance, I’ve always struggled to find a Python UI framework that matches its &quot;async-first&quot; speed without the developer friction. Streamlit is great for prototyping, but the &quot;full script rerun&quot; on every interaction is a performance bottleneck. So, I built Violit. It’s an open-source framework that uses FastAPI as the core engine to deliver a Streamlit-like DX but with O(1) signal-based reactivity. <h1>Demo</h1> <a href="https://i.redd.it/1ws9ruusrbfg1.gif">https://i.redd.it/1ws9ruusrbfg1.gif</a> <h1>Why FastAPI?</h1> I chose FastAPI because I wanted Violit to be production-ready and async-native from day one. <ul> <li>State over WebSockets: Violit maintains a persistent connection via FastAPI’s WebSocket implementation. When a state (Signal) changes, only the specific component updates—no page refreshes or full script reruns.</li> <li>Async-First: Since it’s built on FastAPI, it handles asynchronous tasks (like AI inference or DB queries) without blocking the UI. (This feature will be updated soon.)</li> <li>High Throughput: By leveraging Uvicorn/Starlette under the hood, it scales far better than traditional &quot;rerun-based&quot; frameworks.</li> </ul> <h1>Key Features</h1> <ul> <li>Zero Rerun Architecture: Pure O(1) state updates.</li> <li>90% Streamlit Compatibility: If you know Streamlit, you already know Violit.</li> <li>Shoelace Web Components: Modern, accessible UI elements.</li> <li>30+ Built-in Themes: Switch from &quot;Cyberpunk&quot; to &quot;Dracula&quot; with one line: <code>app.theme(&#39;dracula&#39;)</code>.</li> <li>Native Mode: Package your FastAPI-based web app into a desktop app with <code>--native</code>.</li> </ul> <h1>Simple Example</h1> <pre><code>import violit as vl ​ app = vl.App() count = app.state(0) # Reactive Signal ​ # No full script rerun! # FastAPI handles the WebSocket message and updates only the label. app.button(&quot;Increment&quot;, on_click=lambda: count.set(count.value + 1)) app.write(&quot;Current Count:&quot;, count) ​ app.run() </code></pre> <h1>Feedback Wanted!</h1> As a fellow FastAPI user, I’d love to hear your thoughts on the architecture. Is there anything you&#39;d like to see in a &quot;FastAPI-based frontend&quot; framework? <ul> <li>Repo: <a href="https://github.com/violit-dev/violit">https://github.com/violit-dev/violit</a></li> <li>PyPI: <code>pip install violit</code></li> <li>Example: <ul> <li><a href="https://github.com/violit-dev/violit/blob/main/examples/1_demo_showcase/demo_showcase.py">demo showcase source code</a></li> <li><a href="https://github.com/violit-dev/violit/tree/main/examples/2_violit_blog">(Tutorial) Build Your Own Blog in 10 Minutes with Violit!</a></li> </ul></li> </ul> I’m currently in early Alpha (v0.0.2) and looking for contributors and feedback to make Python web development even faster! </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/Puzzleheaded_Clerk68"> /u/Puzzleheaded_Clerk68 </a> <a href="https://www.reddit.com/r/FastAPI/comments/1qlrjlj/i_built_violit_a_highperformance_ui_framework/">[link]</a> &#32; <a href="https://www.reddit.com/r/FastAPI/comments/1qlrjlj/i_built_violit_a_highperformance_ui_framework/">[comments]</a> </td></tr></table>

Hi everyone,
 I’m a huge fan of the FastAPI ecosystem. While I love FastAPI for its performance, I’ve always struggled to find a Python UI framework that matches its "async-first" speed without the developer friction.
 Streamlit is great for prototyping, but the "full script rerun" on every interaction is a performance bottleneck. So, I built Violit. It’s an open-source framework that uses FastAPI as the core engine to deliver a Streamlit-like DX but with O(1) signal-based reactivity.
 Demo
 https://i.redd.it/1ws9ruusrbfg1.gif
 Why FastAPI?
 I chose FastAPI because I wanted Violit to be production-ready and async-native from day one.
  
State over WebSockets: Violit maintains a persistent connection via FastAPI’s WebSocket implementation. When a state (Signal) changes, only the specific component updates—no page refreshes or full script reruns.
 Async-First: Since it’s built on FastAPI, it handles asynchronous tasks (like AI inference or DB queries) without blocking the UI. (This feature will be updated soon.)
 High Throughput: By leveraging Uvicorn/Starlette under the hood, it scales far better than traditional "rerun-based" frameworks.
  
Key Features
  
Zero Rerun Architecture: Pure O(1) state updates.
 90% Streamlit Compatibility: If you know Streamlit, you already know Violit.
 Shoelace Web Components: Modern, accessible UI elements.
 30+ Built-in Themes: Switch from "Cyberpunk" to "Dracula" with one line: app.theme('dracula').
 Native Mode: Package your FastAPI-based web app into a desktop app with --native.
  
Simple Example
 import violit as vl ​ app = vl.App() count = app.state(0) # Reactive Signal ​ # No full script rerun! # FastAPI handles the WebSocket message and updates only the label. app.button("Increment", on_click=lambda: count.set(count.value + 1)) app.write("Current Count:", count) ​ app.run() 
 Feedback Wanted!
 As a fellow FastAPI user, I’d love to hear your thoughts on the architecture. Is there anything you'd like to see in a "FastAPI-based frontend" framework?
  
Repo: https://github.com/violit-dev/violit
 PyPI: pip install violit
 Example: 
 demo showcase source code
 (Tutorial) Build Your Own Blog in 10 Minutes with Violit!
 
  
I’m currently in early Alpha (v0.0.2) and looking for contributors and feedback to make Python web development even faster!
    submitted by    /u/Puzzleheaded_Clerk68  
 [link]   [comments]

I built "Violit": A High-Performance UI Framework powered by FastAPI & Signals (O(1) reactivity without reruns)

<table> <tr><td> <a href="https://www.reddit.com/r/FastAPI/comments/1qiwgo3/logicpaper_a_selfhosted_document_automation/"> <img src="https://b.thumbs.redditmedia.com/fSRtis8xjTWQZaL98TdU1jNCZlw4-CHWXDPIPzLFDOo.jpg" alt="LogicPaper: A self-hosted document automation engine (FastAPI + LibreOffice + Redis). Turn Excel/JSON into PDFs using Jinja2" title="LogicPaper: A self-hosted document automation engine (FastAPI + LibreOffice + Redis). Turn Excel/JSON into PDFs using Jinja2" /> </a> </td><td> <div class="md">Greetings! I&#39;d like to share a tool I developed called LogicPaper. It’s an open-source document automation engine designed to merge structured data with templates to generate files in bulk. What it does: You upload a template (e.g., Word <code>.docx</code>) using Jinja2 placeholders (like <code>{{ client_name | format_string(&#39;title&#39;) }}</code>) and a dataset (Excel or JSON). LogicPaper processes every row and generates a corresponding filled document for each one. Why I built it: I needed a way to generate hundreds of contracts and reports without manual copy-pasting. It was built to solve a problem at my work, but since I created it in my free time, I decided to make it open source. It fits any workflow that needs standardized docs populated with variable data. Key Features: * Multi-Format: Supports output to <code>.docx</code>, <code>.pptx</code>, <code>.md</code>, and <code>.txt</code>. * Multi-Template Mapping: You can generate multiple file types (e.g., a Contract, a Slide Deck, and a Summary) from a single data row at once. * PDF Conversion: Includes a headless LibreOffice instance to automatically convert the generated Office files to PDF. * Asynchronous Batch Processing: Handles large datasets via background workers to prevent request timeouts. * Integration Ready: It features an API, making it easy to trigger from other self-hosted tools or CRMs. <hr/> It is containerized and ready to deploy. I hope this helps someone :) GitHub Repo: <a href="https://github.com/rubensbraz/logicPaper/">https://github.com/rubensbraz/logicPaper/</a> Placeholders Documentation: <a href="https://rubensbraz.github.io/LogicPaper/help.html">https://rubensbraz.github.io/LogicPaper/help.html</a> </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/Sufficient_Bus_8750"> /u/Sufficient_Bus_8750 </a> <a href="https://www.reddit.com/gallery/1qiwgo3">[link]</a> &#32; <a href="https://www.reddit.com/r/FastAPI/comments/1qiwgo3/logicpaper_a_selfhosted_document_automation/">[comments]</a> </td></tr></table>

Greetings!
 I'd like to share a tool I developed called LogicPaper. It’s an open-source document automation engine designed to merge structured data with templates to generate files in bulk.
 What it does: You upload a template (e.g., Word .docx) using Jinja2 placeholders (like {{ client_name | format_string('title') }}) and a dataset (Excel or JSON). LogicPaper processes every row and generates a corresponding filled document for each one.
 Why I built it: I needed a way to generate hundreds of contracts and reports without manual copy-pasting. It was built to solve a problem at my work, but since I created it in my free time, I decided to make it open source. It fits any workflow that needs standardized docs populated with variable data.
 Key Features: * Multi-Format: Supports output to .docx, .pptx, .md, and .txt. * Multi-Template Mapping: You can generate multiple file types (e.g., a Contract, a Slide Deck, and a Summary) from a single data row at once. * PDF Conversion: Includes a headless LibreOffice instance to automatically convert the generated Office files to PDF. * Asynchronous Batch Processing: Handles large datasets via background workers to prevent request timeouts. * Integration Ready: It features an API, making it easy to trigger from other self-hosted tools or CRMs.
  
It is containerized and ready to deploy. I hope this helps someone :)
 GitHub Repo: https://github.com/rubensbraz/logicPaper/
 Placeholders Documentation: https://rubensbraz.github.io/LogicPaper/help.html
    submitted by    /u/Sufficient_Bus_8750  
 [link]   [comments]

LogicPaper: A self-hosted document automation engine (FastAPI + LibreOffice + Redis). Turn Excel/JSON into PDFs using Jinja2

<div class="md">While starting with FastAPI, I had a lot of trouble getting to understand how concurrency works. I heard of defining async methods but never understand its underlying implications. So I tried to write an article on my understanding and how I used Locust to visualise the concurrency. I would love to hear your feedback on it. <a href="https://medium.com/@bhaveshparvatkar/understanding-concurrency-in-fastapi-fbbe09dc4979">https://medium.com/@bhaveshparvatkar/understanding-concurrency-in-fastapi-fbbe09dc4979</a> </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/BParvatkar"> /u/BParvatkar </a> <a href="https://www.reddit.com/r/FastAPI/comments/1qlkaib/understanding_concurrency_on_fastapi/">[link]</a> &#32; <a href="https://www.reddit.com/r/FastAPI/comments/1qlkaib/understanding_concurrency_on_fastapi/">[comments]</a>

While starting with FastAPI, I had a lot of trouble getting to understand how concurrency works. I heard of defining async methods but never understand its underlying implications. So I tried to write an article on my understanding and how I used Locust to visualise the concurrency. I would love to hear your feedback on it. 
 https://medium.com/@bhaveshparvatkar/understanding-concurrency-in-fastapi-fbbe09dc4979
    submitted by    /u/BParvatkar  
 [link]   [comments]

Understanding concurrency on FastAPI

<div class="md"><a href="https://github.com/p0llopez/fastapi-template">https://github.com/p0llopez/fastapi-template</a> It&#39;s my first open template, I use it in my company in a variety of projects. Maybe you find usefult. Feel free to comment, ask questions, or share ideas. Keep in mind it’s my first time using GitHub Actions and Renovate, so there might be some mess and inconsistencies in there. A bit of vibe code too </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/SuccessfulGround7686"> /u/SuccessfulGround7686 </a> <a href="https://www.reddit.com/r/FastAPI/comments/1qlmkra/another_modern_fastapi_template/">[link]</a> &#32; <a href="https://www.reddit.com/r/FastAPI/comments/1qlmkra/another_modern_fastapi_template/">[comments]</a>

https://github.com/p0llopez/fastapi-template It's my first open template, I use it in my company in a variety of projects. Maybe you find usefult. Feel free to comment, ask questions, or share ideas. Keep in mind it’s my first time using GitHub Actions and Renovate, so there might be some mess and inconsistencies in there. A bit of vibe code too
    submitted by    /u/SuccessfulGround7686  
 [link]   [comments]

Another modern FastApi template

<div class="md">After working with microservices, I kept running into the same annoying problem: reproducing production issues locally is hard (external APIs, DB state, caches, auth, env differences). So I built TimeTracer. What My Project Does Records an API request into a JSON “cassette” (timings + inputs/outputs + dependencies) and lets you replay it locally with dependencies mocked (or hybrid replay). Target Audience Backend developers (FastAPI, Django, Flask, Starlette) who want to debug production issues locally without setting up complex environments. Comparison It’s similar to VCR.py but captures the entire incoming request context (not just outgoing calls) and includes a dashboard. It sits between observability tools and testing mocks. What’s new/cool (v1.6): <ul> <li>Starlette Support: Native support for Starlette apps.</li> <li>Cassette Compression: Now supports GZIP/ZSTD compression to keep storage light (great for big responses).</li> <li>New Dashboard: Enhanced UI to visualize deep dependency chains (e.g. API → DB → External API).</li> <li>Tutorial: I wrote a full guide on debugging 404s with this workflow (link in comments).</li> <li>Pytest integration: Zero-config fixtures (ex: <code>timetracer_replay</code> ) to use cassettes in tests.</li> <li>Broad Support: Works with httpx, requests, aiohttp, SQLAlchemy, and Redis.</li> </ul> Security: <ul> <li>Automatic redaction for tokens/headers.</li> <li>PII detection (emails/phones) so cassettes are safer to share.</li> </ul> Install: <pre><code>pip install timetracer </code></pre> GitHub: <a href="https://github.com/usv240/timetracer">https://github.com/usv240/timetracer</a> Contributions are welcome! If anyone is interested in helping (features, tests, docs), I’d love the support. Full tutorial is mentioned in the comments. Looking for feedback: Does this fit your workflow? What would make you actually use something like this next, better CI integration, more database support, or something else? </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/usv240"> /u/usv240 </a> <a href="https://www.reddit.com/r/FastAPI/comments/1qkjfsh/update_i_built_timetracer_v16_recordreplay_api/">[link]</a> &#32; <a href="https://www.reddit.com/r/FastAPI/comments/1qkjfsh/update_i_built_timetracer_v16_recordreplay_api/">[comments]</a>

After working with microservices, I kept running into the same annoying problem: reproducing production issues locally is hard (external APIs, DB state, caches, auth, env differences).
 So I built TimeTracer.
 What My Project Does Records an API request into a JSON “cassette” (timings + inputs/outputs + dependencies) and lets you replay it locally with dependencies mocked (or hybrid replay).
 Target Audience Backend developers (FastAPI, Django, Flask, Starlette) who want to debug production issues locally without setting up complex environments.
 Comparison It’s similar to VCR.py but captures the entire incoming request context (not just outgoing calls) and includes a dashboard. It sits between observability tools and testing mocks.
 What’s new/cool (v1.6):
  
Starlette Support: Native support for Starlette apps.
 Cassette Compression: Now supports GZIP/ZSTD compression to keep storage light (great for big responses).
 New Dashboard: Enhanced UI to visualize deep dependency chains (e.g. API → DB → External API).
 Tutorial: I wrote a full guide on debugging 404s with this workflow (link in comments).
 Pytest integration: Zero-config fixtures (ex: timetracer_replay ) to use cassettes in tests.
 Broad Support: Works with httpx, requests, aiohttp, SQLAlchemy, and Redis.
  
Security:
  
Automatic redaction for tokens/headers.
 PII detection (emails/phones) so cassettes are safer to share.
  
Install: 
 pip install timetracer 
 GitHub: https://github.com/usv240/timetracer
 Contributions are welcome! If anyone is interested in helping (features, tests, docs), I’d love the support.
 Full tutorial is mentioned in the comments.
 Looking for feedback: Does this fit your workflow? What would make you actually use something like this next, better CI integration, more database support, or something else?
    submitted by    /u/usv240  
 [link]   [comments]

Update: I built TimeTracer (v1.6), record/replay API calls locally + dashboard (Starlette/FastAPI/Django)

<div class="md">After working with microservices, I kept running into the same annoying problem: reproducing production issues locally is hard (external APIs, DB state, caches, auth, env differences). So I built TimeTracer. What it does: <ul> <li>Records an API request into a JSON “cassette” (timings + inputs/outputs)</li> <li>Lets you replay it locally with dependencies mocked (or hybrid replay)</li> </ul> What’s new/cool (v1.3 &amp; v1.4): <ul> <li>Built-in dashboard + timeline view to inspect requests, failures, and slow calls</li> <li>FastAPI + Flask support</li> <li>Django support (Django 3.2+ and 4.x, supports sync + async views)</li> <li>pytest integration with zero-config fixtures (ex: <code>timetracer_replay</code>) to replay cassettes inside tests</li> <li>aiohttp support (now supports the big 3 HTTP clients: httpx, requests, aiohttp)</li> </ul> Supports capturing: httpx, requests, aiohttp, SQLAlchemy, and Redis Security: <ul> <li>More automatic redaction for tokens/headers</li> <li>PII detection (emails/phones/etc.) so cassettes are safer to share</li> </ul> Install: <code>pip install timetracer</code> GitHub: <a href="https://github.com/usv240/timetracer">https://github.com/usv240/timetracer</a> Contributions are welcome, if anyone is interested in helping (features, tests, docs, or new integrations), I’d love the support. Looking for feedback: Does this fit your workflow? What would make you actually use something like this next, better CI integration, more database support, improved diffing, or something else? </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/usv240"> /u/usv240 </a> <a href="https://www.reddit.com/r/FastAPI/comments/1qhd0ve/update_i_built_timetracer_recordreplay_api_calls/">[link]</a> &#32; <a href="https://www.reddit.com/r/FastAPI/comments/1qhd0ve/update_i_built_timetracer_recordreplay_api_calls/">[comments]</a>

After working with microservices, I kept running into the same annoying problem: reproducing production issues locally is hard (external APIs, DB state, caches, auth, env differences).
 So I built TimeTracer.
 What it does:
  
Records an API request into a JSON “cassette” (timings + inputs/outputs)
 Lets you replay it locally with dependencies mocked (or hybrid replay)
  
What’s new/cool (v1.3 & v1.4):
  
Built-in dashboard + timeline view to inspect requests, failures, and slow calls
 FastAPI + Flask support
 Django support (Django 3.2+ and 4.x, supports sync + async views)
 pytest integration with zero-config fixtures (ex: timetracer_replay) to replay cassettes inside tests
 aiohttp support (now supports the big 3 HTTP clients: httpx, requests, aiohttp)
  
Supports capturing:
 httpx, requests, aiohttp, SQLAlchemy, and Redis
 Security:
  
More automatic redaction for tokens/headers
 PII detection (emails/phones/etc.) so cassettes are safer to share
  
Install:
 pip install timetracer
 GitHub:
 https://github.com/usv240/timetracer
 Contributions are welcome, if anyone is interested in helping (features, tests, docs, or new integrations), I’d love the support.
 Looking for feedback:
 Does this fit your workflow? What would make you actually use something like this next, better CI integration, more database support, improved diffing, or something else?
    submitted by    /u/usv240  
 [link]   [comments]

Update: I built TimeTracer, record/replay API calls locally + dashboard (Django/FastAPI/Flask)

<div class="md">I’ve been deep into FastAPI for a while and noticed how much great content is scattered across blogs, repos, and other community projects. Sometimes it’s hard to discover high-quality posts, tutorials, or tools unless you already know they exist — so I built something to help with that. 👉 FastAPI Blogs &amp; Tools Directory — <a href="https://fastapiblogs.fly.dev/">https://fastapiblogs.fly.dev/</a> <h1>What it does</h1> This site is a curated directory of: <ul> <li>🔗 Blog posts &amp; tutorials about FastAPI</li> <li>🛠️ Tools, libraries, and starter kits on GitHub or elsewhere</li> <li>📚 Helpful resources for learning, building, and deploying FastAPI apps</li> </ul> Instead of digging through search results or bookmarks, you can browse by topic and discover content others have shared. It’s open-source and community-focused — not a commercial project. <h1>How it helps the community</h1> <ul> <li>📍 A single place to find interesting FastAPI content</li> <li>🧠 Helps newbies and experienced devs alike discover articles, guides, and tools</li> <li>🤝 Encourages authors to share their work and get visibility</li> <li>🛠️ All links point to original sources — no scraping or reposting of full content</li> </ul> <h1>Built with community in mind</h1> The idea came from seeing posts like “I built X, what do you think?” where people share projects and ask for feedback, and the community actively engages. I’d love to get your thoughts on: <ul> <li>What categories or tags you think should exist</li> <li>Good FastAPI blogs or repos that are missing</li> <li>Ways to improve the browsing experience</li> </ul> I’m happy to expand this into something more collaborative (e.g., letting users submit links) if there’s demand for it. Thanks for reading — excited to hear what you think! 🧡 </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/ej_Ad8786"> /u/ej_Ad8786 </a> <a href="https://www.reddit.com/r/FastAPI/comments/1qg3qvl/i_built_fastapi_blogs_tools_directory_a_curated/">[link]</a> &#32; <a href="https://www.reddit.com/r/FastAPI/comments/1qg3qvl/i_built_fastapi_blogs_tools_directory_a_curated/">[comments]</a>

I’ve been deep into FastAPI for a while and noticed how much great content is scattered across blogs, repos, and other community projects. Sometimes it’s hard to discover high-quality posts, tutorials, or tools unless you already know they exist — so I built something to help with that.
 👉 FastAPI Blogs & Tools Directory — https://fastapiblogs.fly.dev/
 What it does
 This site is a curated directory of:
  
🔗 Blog posts & tutorials about FastAPI
 🛠️ Tools, libraries, and starter kits on GitHub or elsewhere
 📚 Helpful resources for learning, building, and deploying FastAPI apps
  
Instead of digging through search results or bookmarks, you can browse by topic and discover content others have shared. It’s open-source and community-focused — not a commercial project.
 How it helps the community
  
📍 A single place to find interesting FastAPI content
 🧠 Helps newbies and experienced devs alike discover articles, guides, and tools
 🤝 Encourages authors to share their work and get visibility
 🛠️ All links point to original sources — no scraping or reposting of full content
  
Built with community in mind
 The idea came from seeing posts like “I built X, what do you think?” where people share projects and ask for feedback, and the community actively engages. I’d love to get your thoughts on:
  
What categories or tags you think should exist
 Good FastAPI blogs or repos that are missing
 Ways to improve the browsing experience
  
I’m happy to expand this into something more collaborative (e.g., letting users submit links) if there’s demand for it.
 Thanks for reading — excited to hear what you think! 🧡
    submitted by    /u/ej_Ad8786  
 [link]   [comments]

🚀 I built FastAPI Blogs & Tools Directory — a curated resource hub for FastAPI-related content, blogs & open-source tools

<div class="md">I kept on running into an issue where i needed to host some files on my server and let others download at their own time, but the files should not exist on the server for an indefinite amount of time. So i built an encrypted file/folder sharing platform with automatic file eviction logic. <h1>What it does:</h1> <ul> <li>Allows users to upload files without sign up.</li> <li>Automatic File eviction from the s3 (rustfs) storage.</li> <li>Client side encryption, the server is just a dumb interface between frontend and the s3 storage.</li> </ul> <h1>What makes it different:</h1> <ul> <li>Customizable limits from the frontend ui (which is not present in firefox send)</li> <li>Future support for CLI and TUI</li> <li>Anything the community desires</li> </ul> Check it out at: <a href="https://chithi.dev">https://chithi.dev</a> Please do note that the public server is running from a core 2 duo with 4gb RAM with a 250Mbps uplink shared with my home connection that is running a lot of <a href="https://github.com/baseplate-admin/homelab">services</a>. Thanks for reading! Happy to have any kind of feedbacks :) <hr/> For anyone wondering about some fancy fastapi things i implemented in the project - Global Ratelimiter via <a href="https://github.com/chithi-dev/chithi/blob/c84de03dbe18f9a6b9f5295cf12da7734f5399a8/src/backend/app/main.py">Depends</a>: <a href="https://github.com/chithi-dev/chithi/blob/c84de03dbe18f9a6b9f5295cf12da7734f5399a8/src/backend/app/guards/rate_limit.py#L27-L46">Guards</a> and <a href="https://github.com/chithi-dev/chithi/blob/c84de03dbe18f9a6b9f5295cf12da7734f5399a8/src/backend/app/routes/login.py#L19">decorator</a> - <a href="https://github.com/chithi-dev/chithi/blob/c84de03dbe18f9a6b9f5295cf12da7734f5399a8/src/backend/app/routes/upload.py#L89-L157">Chunked S3 Uploads</a> <hr/> Admin UI Pictures: <a href="https://ibb.co.com/20Rq2JPG">Image 1</a> <a href="https://ibb.co.com/TB723LNp">Image 2</a> <a href="https://ibb.co.com/nh2Xfjb">Image 3</a> </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/BasePlate_Admin"> /u/BasePlate_Admin </a> <a href="https://www.reddit.com/r/FastAPI/comments/1qh5144/i_built_chithidev_an_encrypted_file_sharing/">[link]</a> &#32; <a href="https://www.reddit.com/r/FastAPI/comments/1qh5144/i_built_chithidev_an_encrypted_file_sharing/">[comments]</a>

I kept on running into an issue where i needed to host some files on my server and let others download at their own time, but the files should not exist on the server for an indefinite amount of time.
 So i built an encrypted file/folder sharing platform with automatic file eviction logic.
 What it does:
  
Allows users to upload files without sign up.
 Automatic File eviction from the s3 (rustfs) storage.
 Client side encryption, the server is just a dumb interface between frontend and the s3 storage.
  
What makes it different:
  
Customizable limits from the frontend ui (which is not present in firefox send)
 Future support for CLI and TUI
 Anything the community desires
  
Check it out at: https://chithi.dev
 Please do note that the public server is running from a core 2 duo with 4gb RAM with a 250Mbps uplink shared with my home connection that is running a lot of services.
 Thanks for reading! Happy to have any kind of feedbacks :) 
  
For anyone wondering about some fancy fastapi things i implemented in the project - Global Ratelimiter via Depends: Guards and decorator - Chunked S3 Uploads
  
Admin UI Pictures: Image 1 Image 2 Image 3
    submitted by    /u/BasePlate_Admin  
 [link]   [comments]

I built chithi.dev, an Encrypted file sharing platform that is heavily inspired from firefox-send built on zero-trust server.

<table> <tr><td> <a href="https://www.reddit.com/r/FastAPI/comments/1qlgcb4/how_to_connect_fastapi_to_postgresql/"> <img src="https://external-preview.redd.it/JdTrtYx73BR2ZF4K90lEJJDZ6O4kJmTBTWFD6W1rBkI.jpeg?width=640&amp;crop=smart&amp;auto=webp&amp;s=b7b5773bd747fb1466738e2e00ad4d4dbb460d72" alt="How to Connect FastAPI to PostgreSQL" title="How to Connect FastAPI to PostgreSQL" /> </a> </td><td> &#32; submitted by &#32; <a href="https://www.reddit.com/user/thirdy454"> /u/thirdy454 </a> <a href="https://thirdygayares.com/FastAPI/how-to-connect-fastapi-to-postgres">[link]</a> &#32; <a href="https://www.reddit.com/r/FastAPI/comments/1qlgcb4/how_to_connect_fastapi_to_postgresql/">[comments]</a> </td></tr></table>

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

How to Connect FastAPI to PostgreSQL

&#32; submitted by &#32; <a href="https://www.reddit.com/user/async-lambda"> /u/async-lambda </a> <a href="/r/vercel/comments/1qjqwc3/help_regarding_astrojs_fastapi/">[link]</a> &#32; <a href="https://www.reddit.com/r/FastAPI/comments/1qjqz0x/help_regarding_astrojs_fastapi/">[comments]</a>

submitted by    /u/async-lambda  
 [link]   [comments]

Help regarding Astro.js + FastAPI

&#32; submitted by &#32; <a href="https://www.reddit.com/user/VanillaOk4593"> /u/VanillaOk4593 </a> <a href="/r/LangChain/comments/1qgekmg/fastapifullstack_v0115_released_now_with/">[link]</a> &#32; <a href="https://www.reddit.com/r/FastAPI/comments/1qgg7wa/fastapifullstack_v0115_released_now_with/">[comments]</a>

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

fastapi-fullstack v0.1.15 released – now with DeepAgents (LangChain's multi-agent framework) + HITL support!

<div class="md"><pre><code>from fastapi import FastAPI, Request from fastapi.responses import JSONResponse from starlette.exceptions import HTTPException as StarletteHTTPException def register_psyop_handler(app: FastAPI) -&gt; None: &quot;&quot;&quot; Registers the 404 handler for routes that never existed. &quot;&quot;&quot; @app.exception_handler(StarletteHTTPException) async def the_endpoint_was_a_psyop( request: Request, exc: StarletteHTTPException, ) -&gt; JSONResponse: if exc.status_code == 404: return JSONResponse( status_code = 404, content = { &quot;detail&quot;: &quot;It was never real. The endpoint was a psyop.&quot; }, ) return JSONResponse( status_code = exc.status_code, content = {&quot;detail&quot;: exc.detail}, ) </code></pre> </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/Hopeful_Beat7161"> /u/Hopeful_Beat7161 </a> <a href="https://www.reddit.com/r/FastAPI/comments/1qkkh8e/it_was_never_real/">[link]</a> &#32; <a href="https://www.reddit.com/r/FastAPI/comments/1qkkh8e/it_was_never_real/">[comments]</a>

from fastapi import FastAPI, Request from fastapi.responses import JSONResponse from starlette.exceptions import HTTPException as StarletteHTTPException def register_psyop_handler(app: FastAPI) -> None: """ Registers the 404 handler for routes that never existed. """ @app.exception_handler(StarletteHTTPException) async def the_endpoint_was_a_psyop( request: Request, exc: StarletteHTTPException, ) -> JSONResponse: if exc.status_code == 404: return JSONResponse( status_code = 404, content = { "detail": "It was never real. The endpoint was a psyop." }, ) return JSONResponse( status_code = exc.status_code, content = {"detail": exc.detail}, ) 
    submitted by    /u/Hopeful_Beat7161  
 [link]   [comments]

It was never real

<div class="md">hi everyone. I&#39;m new to development. I&#39;ve been learning flask by watching youtube videos. but i don&#39;t think i&#39;m doing enough. there are a lot of things that needed to be remembered unlike programming languages. As we used to solve small problems while learning programming language to do it better, what should i do while learning flask or anything related to development or any framework? Thanks </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/Grouchy_Initial_1911"> /u/Grouchy_Initial_1911 </a> <a href="https://www.reddit.com/r/flask/comments/1qh9oo8/how_to_learn_flask_or_other_frameworks/">[link]</a> &#32; <a href="https://www.reddit.com/r/flask/comments/1qh9oo8/how_to_learn_flask_or_other_frameworks/">[comments]</a>

hi everyone. 
 I'm new to development. I've been learning flask by watching youtube videos. but i don't think i'm doing enough. there are a lot of things that needed to be remembered unlike programming languages. As we used to solve small problems while learning programming language to do it better, what should i do while learning flask or anything related to development or any framework?
 Thanks 
    submitted by    /u/Grouchy_Initial_1911  
 [link]   [comments]

how to learn flask or other frameworks?

<div class="md">Hey, We have a schoolproject where we need to make an website with temperature data with an esp32 and an DT22 everything works fine but we need to make a sql and our teacher told us to try mysql workbench but we are stuck any suggestions maybe better options ? </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/fixihartmann190"> /u/fixihartmann190 </a> <a href="https://www.reddit.com/r/flask/comments/1qh0x70/school_project/">[link]</a> &#32; <a href="https://www.reddit.com/r/flask/comments/1qh0x70/school_project/">[comments]</a>

Hey,
 We have a schoolproject where we need to make an website with temperature data with an esp32 and an DT22 everything works fine but we need to make a sql and our teacher told us to try mysql workbench but we are stuck any suggestions maybe better options ?
    submitted by    /u/fixihartmann190  
 [link]   [comments]

School project

<div class="md">Hey Everyone, firstly, I apologize if this has been asked before. I have an assignment for a position to get an internship. The first assignment was to create a ChatBot that uses two different LLM. It takes user input, and outputs the response from the selected LLM. ------------------------------------------------------------------------------------- <a href="https://github.com/wirrexx/IntelliVerse_task">https://github.com/wirrexx/IntelliVerse_task</a> ----------------------------- result so far: <a href="http://wirrexx.pythonanywhere.com">wirrexx.pythonanywhere.com</a> ----------------------------- Backend: <ol> <li>Function to call first LLM</li> <li>Function to call second LLM. </li> <li>Index function to Get and Post information. </li> </ol> Frontend: Html (with Jinja) and css to show the result. ----------------------------- Now the new task is, to implement 3 more LLMs(check, but not updated). User Input, Output response from all LLMs at the same time and show how long each response took. My thought process for this is to create a time wrapper, that takes a name, function and prompt. <ol> <li>have a start variable</li> <li>elapsed_time variable</li> </ol> and that&#39;s where my head stops to work. How do i Call on every function simultionusly and connect it properly to the html page. I&#39;m open for multiple tips, tricks, ideas and thinking. Pointing me towards the right direction would be very helpful! Thank you so much </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/wirrexx"> /u/wirrexx </a> <a href="https://www.reddit.com/r/flask/comments/1qkj73n/need_help_to_figure_this_one_out/">[link]</a> &#32; <a href="https://www.reddit.com/r/flask/comments/1qkj73n/need_help_to_figure_this_one_out/">[comments]</a>

Hey Everyone, firstly, I apologize if this has been asked before. 
 I have an assignment for a position to get an internship.
 The first assignment was to create a ChatBot that uses two different LLM. 
 It takes user input, and outputs the response from the selected LLM. 
 ------------------------------------------------------------------------------------- 
 https://github.com/wirrexx/IntelliVerse_task
 -----------------------------
 result so far:
 wirrexx.pythonanywhere.com
 -----------------------------
 Backend: 
  
Function to call first LLM
 
Function to call second LLM. 
 
Index function to Get and Post information. 
 
 Frontend:
 Html (with Jinja) and css to show the result. 
 -----------------------------
 Now the new task is, to implement 3 more LLMs(check, but not updated).
 User Input, Output response from all LLMs at the same time and show how long each response took. 
 My thought process for this is to create a time wrapper, that takes a name, function and prompt.
  
have a start variable
 
elapsed_time variable
 
 and that's where my head stops to work. 
 How do i Call on every function simultionusly and connect it properly to the html page. 
 I'm open for multiple tips, tricks, ideas and thinking. Pointing me towards the right direction would be very helpful!
 Thank you so much
    submitted by    /u/wirrexx  
 [link]   [comments]

Need help to figure this one out!

<div class="md">On the first image you can see a visual of the official GitHub repo of Django. Each of these dots is a Python file. The red ones are the most complex whilst green means low complexity. Each line represents a connection between the files (usually an import) The second image shows the AST of the main init file… complexity again highlighted in red. The level of complexity literally blew me away.. kudos to all maintainers! </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/swupel_"> /u/swupel_ </a> <a href="https://www.reddit.com/gallery/1qjwxju">[link]</a> &#32; <a href="https://www.reddit.com/r/django/comments/1qjwxju/djangos_true_complexity/">[comments]</a>

On the first image you can see a visual of the official GitHub repo of Django.
 Each of these dots is a Python file. 
 The red ones are the most complex whilst green means low complexity.
 Each line represents a connection between the files (usually an import)
 The second image shows the AST of the main init file… complexity again highlighted in red.
 The level of complexity literally blew me away.. kudos to all maintainers!
    submitted by    /u/swupel_  
 [link]   [comments]

Djangos True Complexity

<div class="md">Hey everyone, I benchmarked the major Python frameworks with real PostgreSQL workloads: complex queries, nested relationships, and properly optimized eager loading for each framework (select_related/prefetch_related for Django, selectinload for SQLAlchemy). Each framework tested with multiple servers (Uvicorn, Granian, Gunicorn) in isolated Docker containers with strict resource limits. All database queries are optimized using each framework&#39;s best practices - this is a fair comparison of properly-written production code, not naive implementations. Key finding: performance differences collapse from 20x (JSON) to 1.3x (complex DB queries). Database I/O is the great equalizer - framework choice barely matters for database-heavy apps. Full results, code, and a reproducible Docker setup are here: <a href="https://github.com/huynguyengl99/python-api-frameworks-benchmark">https://github.com/huynguyengl99/python-api-frameworks-benchmark</a> If this is useful, a GitHub star would be appreciated 😄 <h1>Frameworks &amp; Servers Tested</h1> <ul> <li>Django Bolt (runbolt server)</li> <li>FastAPI (fastapi-uvicorn, fastapi-granian)</li> <li>Litestar (litestar-uvicorn, litestar-granian)</li> <li>Django REST Framework (drf-uvicorn, drf-granian, drf-gunicorn)</li> <li>Django Ninja (ninja-uvicorn, ninja-granian)</li> </ul> Each framework tested with multiple production servers: Uvicorn (ASGI), Granian (Rust-based ASGI/WSGI), and Gunicorn+gevent (async workers). <h1>Test Setup</h1> <ul> <li>Hardware: MacBook M2 Pro, 32GB RAM</li> <li>Database: PostgreSQL with realistic data (500 articles, 2000 comments, 100 tags, 50 authors)</li> <li>Docker Isolation: Each framework runs in its own container with strict resource limits: <ul> <li>750MB RAM limit (--memory=750m)</li> <li>1 CPU core limit (--cpus=1)</li> <li>Sequential execution (start → benchmark → stop → next framework)</li> </ul></li> <li>Load: 100 concurrent connections, 10s duration, 3 runs (best taken)</li> </ul> This setup ensures completely fair comparison - no resource contention between frameworks, each gets identical isolated environment. <h1>Endpoints Tested</h1> <ol> <li><code>/json-1k</code> - Simple 1KB JSON serialization</li> <li><code>/json-10k</code> - Large 10KB JSON serialization</li> <li><code>/db</code> - 10 simple database reads</li> <li><code>/articles?page=1&amp;page_size=20</code> - Paginated articles with nested authors + tags</li> <li><code>/articles/1</code> - Single article with author, tags, and all comments</li> </ol> <h1>Key Results</h1> <a href="https://preview.redd.it/tmjzm5d2p8fg1.png?width=2083&amp;format=png&amp;auto=webp&amp;s=388bc72d940a7302b5b65d81baa0b3fbd369fcc0">https://preview.redd.it/tmjzm5d2p8fg1.png?width=2083&amp;format=png&amp;auto=webp&amp;s=388bc72d940a7302b5b65d81baa0b3fbd369fcc0</a> <h1>Simple JSON (/json-1k) - RPS</h1> <ul> <li>litestar-uvicorn: 31,745</li> <li>litestar-granian: 22,523</li> <li>bolt: 22,289</li> <li>fastapi-uvicorn: 12,838</li> <li>drf-gunicorn: 4,271</li> <li>drf-uvicorn: 1,582</li> </ul> 20x performance difference between fastest and slowest. <h1>Real Database - Paginated Articles (/articles?page=1&amp;page_size=20) - RPS</h1> <a href="https://preview.redd.it/5bmqnfx8p8fg1.png?width=1484&amp;format=png&amp;auto=webp&amp;s=da634c76ac2785a5305cbb28e1e9483a667297df">https://preview.redd.it/5bmqnfx8p8fg1.png?width=1484&amp;format=png&amp;auto=webp&amp;s=da634c76ac2785a5305cbb28e1e9483a667297df</a> <ul> <li>litestar-uvicorn: 253</li> <li>litestar-granian: 238</li> <li>bolt: 237</li> <li>fastapi-uvicorn: 225</li> <li>drf-granian: 221</li> </ul> Performance gap shrinks to just 1.7x when hitting the database. Query optimization becomes the bottleneck. <h1>Real Database - Article Detail (/articles/1) - RPS</h1> <a href="https://preview.redd.it/2svzsfyep8fg1.png?width=1484&amp;format=png&amp;auto=webp&amp;s=477464b87fd0c98af9825717bef33a1c64ebc105">https://preview.redd.it/2svzsfyep8fg1.png?width=1484&amp;format=png&amp;auto=webp&amp;s=477464b87fd0c98af9825717bef33a1c64ebc105</a> Single article with all nested data (author + tags + comments): <ul> <li>fastapi-uvicorn: 550</li> <li>litestar-granian: 543</li> <li>litestar-uvicorn: 519</li> <li>bolt: 487</li> <li>fastapi-granian: 480</li> </ul> Gap narrows to 1.3x - frameworks perform nearly identically on complex database queries. <h1>Resource Usage Insight</h1> <a href="https://preview.redd.it/pg1obo5qp8fg1.png?width=2084&amp;format=png&amp;auto=webp&amp;s=05e08b41926718f7c2b027582a018c7a8e5438fa">https://preview.redd.it/pg1obo5qp8fg1.png?width=2084&amp;format=png&amp;auto=webp&amp;s=05e08b41926718f7c2b027582a018c7a8e5438fa</a> Memory: <ul> <li>Most frameworks: 170-220MB</li> <li>DRF-Granian: 640-670MB (WSGI interface vs ASGI for others - Granian&#39;s WSGI mode uses more memory)</li> </ul> CPU: <ul> <li>Most frameworks saturate the 1 CPU limit (100%+) under load</li> <li>Granian variants consistently max out CPU across all frameworks</li> </ul> <h1>Server Performance</h1> <ul> <li>Uvicorn surprisingly won for Litestar (31,745 RPS), beating Granian</li> <li>Granian delivered consistent high performance for FastAPI and other frameworks</li> <li>Gunicorn + gevent showed good performance for DRF on simple queries, but struggled with database workloads</li> </ul> <h1>Key Takeaways</h1> <ol> <li>Performance gap collapse: 20x difference in JSON serialization → 1.7x in paginated queries → 1.3x in complex queries</li> <li>Litestar-Uvicorn dominates simple workloads (31,745 RPS), but FastAPI-Uvicorn wins on complex database queries (550 RPS)</li> <li>Database I/O is the equalizer: Once you hit the database, framework overhead becomes negligible. Query optimization matters infinitely more than framework choice.</li> <li>WSGI uses more memory: Granian&#39;s WSGI mode (DRF-Granian) uses 640MB vs ~200MB for ASGI variants - just a difference in protocol handling, not a performance issue.</li> </ol> Bottom line: If you&#39;re building a database-heavy API (which most are), spend your time optimizing queries, not choosing between frameworks. They all perform nearly identically when properly optimized. <pre><code>Inspired by https://github.com/tanrax/python-api-frameworks-benchmark/ </code></pre> </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/huygl99"> /u/huygl99 </a> <a href="https://www.reddit.com/r/django/comments/1qlfgkr/python_api_framework_benchmark_fastapi_vs/">[link]</a> &#32; <a href="https://www.reddit.com/r/django/comments/1qlfgkr/python_api_framework_benchmark_fastapi_vs/">[comments]</a>

Hey everyone,
 I benchmarked the major Python frameworks with real PostgreSQL workloads: complex queries, nested relationships, and properly optimized eager loading for each framework (select_related/prefetch_related for Django, selectinload for SQLAlchemy). Each framework tested with multiple servers (Uvicorn, Granian, Gunicorn) in isolated Docker containers with strict resource limits.
 All database queries are optimized using each framework's best practices - this is a fair comparison of properly-written production code, not naive implementations.
 Key finding: performance differences collapse from 20x (JSON) to 1.3x (complex DB queries). Database I/O is the great equalizer - framework choice barely matters for database-heavy apps.
 Full results, code, and a reproducible Docker setup are here: https://github.com/huynguyengl99/python-api-frameworks-benchmark
 If this is useful, a GitHub star would be appreciated 😄
 Frameworks & Servers Tested
  
Django Bolt (runbolt server)
 FastAPI (fastapi-uvicorn, fastapi-granian)
 Litestar (litestar-uvicorn, litestar-granian)
 Django REST Framework (drf-uvicorn, drf-granian, drf-gunicorn)
 Django Ninja (ninja-uvicorn, ninja-granian)
  
Each framework tested with multiple production servers: Uvicorn (ASGI), Granian (Rust-based ASGI/WSGI), and Gunicorn+gevent (async workers).
 Test Setup
  
Hardware: MacBook M2 Pro, 32GB RAM
 Database: PostgreSQL with realistic data (500 articles, 2000 comments, 100 tags, 50 authors)
 Docker Isolation: Each framework runs in its own container with strict resource limits: 
 750MB RAM limit (--memory=750m)
 1 CPU core limit (--cpus=1)
 Sequential execution (start → benchmark → stop → next framework)
 
 Load: 100 concurrent connections, 10s duration, 3 runs (best taken)
  
This setup ensures completely fair comparison - no resource contention between frameworks, each gets identical isolated environment.
 Endpoints Tested
  
/json-1k - Simple 1KB JSON serialization
 /json-10k - Large 10KB JSON serialization
 /db - 10 simple database reads
 /articles?page=1&page_size=20 - Paginated articles with nested authors + tags
 /articles/1 - Single article with author, tags, and all comments
  
Key Results
 https://preview.redd.it/tmjzm5d2p8fg1.png?width=2083&format=png&auto=webp&s=388bc72d940a7302b5b65d81baa0b3fbd369fcc0
 Simple JSON (/json-1k) - RPS
  
litestar-uvicorn: 31,745
 litestar-granian: 22,523
 bolt: 22,289
 fastapi-uvicorn: 12,838
 drf-gunicorn: 4,271
 drf-uvicorn: 1,582
  
20x performance difference between fastest and slowest.
 Real Database - Paginated Articles (/articles?page=1&page_size=20) - RPS
 https://preview.redd.it/5bmqnfx8p8fg1.png?width=1484&format=png&auto=webp&s=da634c76ac2785a5305cbb28e1e9483a667297df
  
litestar-uvicorn: 253
 litestar-granian: 238
 bolt: 237
 fastapi-uvicorn: 225
 drf-granian: 221
  
Performance gap shrinks to just 1.7x when hitting the database. Query optimization becomes the bottleneck.
 Real Database - Article Detail (/articles/1) - RPS
 https://preview.redd.it/2svzsfyep8fg1.png?width=1484&format=png&auto=webp&s=477464b87fd0c98af9825717bef33a1c64ebc105
 Single article with all nested data (author + tags + comments):
  
fastapi-uvicorn: 550
 litestar-granian: 543
 litestar-uvicorn: 519
 bolt: 487
 fastapi-granian: 480
  
Gap narrows to 1.3x - frameworks perform nearly identically on complex database queries.
 Resource Usage Insight
 https://preview.redd.it/pg1obo5qp8fg1.png?width=2084&format=png&auto=webp&s=05e08b41926718f7c2b027582a018c7a8e5438fa
 Memory:
  
Most frameworks: 170-220MB
 DRF-Granian: 640-670MB (WSGI interface vs ASGI for others - Granian's WSGI mode uses more memory)
  
CPU:
  
Most frameworks saturate the 1 CPU limit (100%+) under load
 Granian variants consistently max out CPU across all frameworks
  
Server Performance
  
Uvicorn surprisingly won for Litestar (31,745 RPS), beating Granian
 Granian delivered consistent high performance for FastAPI and other frameworks
 Gunicorn + gevent showed good performance for DRF on simple queries, but struggled with database workloads
  
Key Takeaways
  
Performance gap collapse: 20x difference in JSON serialization → 1.7x in paginated queries → 1.3x in complex queries
 Litestar-Uvicorn dominates simple workloads (31,745 RPS), but FastAPI-Uvicorn wins on complex database queries (550 RPS)
 Database I/O is the equalizer: Once you hit the database, framework overhead becomes negligible. Query optimization matters infinitely more than framework choice.
 WSGI uses more memory: Granian's WSGI mode (DRF-Granian) uses 640MB vs ~200MB for ASGI variants - just a difference in protocol handling, not a performance issue.
  
Bottom line: If you're building a database-heavy API (which most are), spend your time optimizing queries, not choosing between frameworks. They all perform nearly identically when properly optimized.
 Inspired by https://github.com/tanrax/python-api-frameworks-benchmark/ 
    submitted by    /u/huygl99  
 [link]   [comments]

Python API Framework Benchmark: FastAPI vs Litestar vs DRF vs Django Ninja vs Django Bolt - Real Database Querie

<div class="md">Born from using the Django + Celery combination for many years, dj-celery-panel is a monitoring solution for celery built into the django admin; This means no other services or processes to deploy to check up on your task setup. <ul> <li><a href="https://github.com/yassi/dj-celery-panel">git repo</a></li> <li><a href="https://pypi.org/project/dj-celery-panel/">pypi</a></li> <li><a href="https://yassi.github.io/dj-celery-panel/">docs</a></li> </ul> This is the third in a series of projects that use the django admin as a surface for deploying useful observability tools. Also check out dj-redis-panel and dj-cache-panel </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/yassi_dev"> /u/yassi_dev </a> <a href="https://yassi.dev/projects/dj-celery-panel/">[link]</a> &#32; <a href="https://www.reddit.com/r/django/comments/1qix9ng/djcelerypanel_replace_your_flower_instance_with/">[comments]</a>

Born from using the Django + Celery combination for many years, dj-celery-panel is a monitoring solution for celery built into the django admin; This means no other services or processes to deploy to check up on your task setup.
  
git repo
 pypi
 docs
  
This is the third in a series of projects that use the django admin as a surface for deploying useful observability tools. Also check out dj-redis-panel and dj-cache-panel
    submitted by    /u/yassi_dev  
 [link]   [comments]

dj-celery-panel: Replace your flower instance with monitoring right inside the admin

&#32; submitted by &#32; <a href="https://www.reddit.com/user/Ill_Leading9202"> /u/Ill_Leading9202 </a> <a href="/r/webdev/comments/1qi3ad4/is_django_still_a_good_choice_in_2026_for_modern/">[link]</a> &#32; <a href="https://www.reddit.com/r/django/comments/1qib6dg/is_django_still_a_good_choice_in_2026_for_modern/">[comments]</a>

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

Is DJANGO still a good choice in 2026 for modern web apps?

&#32; submitted by &#32; <a href="https://www.reddit.com/user/kivarada"> /u/kivarada </a> <a href="https://www.loopwerk.io/articles/2026/django-tasks-review/">[link]</a> &#32; <a href="https://www.reddit.com/r/django/comments/1qhlvvs/django_60_tasks_a_framework_without_a_worker/">[comments]</a>

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

Django 6.0 Tasks: a framework without a worker

&#32; submitted by &#32; <a href="https://www.reddit.com/user/jcmetz21"> /u/jcmetz21 </a> <a href="https://johnnymetz.com/posts/avoiding-duplicate-objects-in-django-querysets/">[link]</a> &#32; <a href="https://www.reddit.com/r/django/comments/1qkvtiu/avoiding_duplicate_objects_in_django_querysets/">[comments]</a>

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

Avoiding Duplicate Objects in Django Querysets

<div class="md">Hi fellow Django developers Unlike Laravel or Rails, Django doesn&#39;t provide official guidance on modern frontend integration. So I built django-vite-boilerplate, an open-source project that brings modern frontend tooling to Django with just one command: <code>bash python manage.py vite_init </code> You can choose your stacks and everything would be setup: <ul> <li>JS: HTMX + Alpine.js, Vanilla.js, or Hotwire</li> <li>CSS: Tailwind, DaisyUI, or Bootstrap</li> </ul> Plus, it includes auto-reload in development - no more manual refreshing when you edit code! React, Vue support will come soon! Hope it can help developers here. Link: <a href="https://saashammer.com/blog/django-vite-boilerplate/">https://saashammer.com/blog/django-vite-boilerplate/</a> </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/1qjrypi/supercharge_your_django_frontend_with_vite_a/">[link]</a> &#32; <a href="https://www.reddit.com/r/django/comments/1qjrypi/supercharge_your_django_frontend_with_vite_a/">[comments]</a>

Hi fellow Django developers
 Unlike Laravel or Rails, Django doesn't provide official guidance on modern frontend integration.
 So I built django-vite-boilerplate, an open-source project that brings modern frontend tooling to Django with just one command:
 bash python manage.py vite_init 
 You can choose your stacks and everything would be setup:
  
JS: HTMX + Alpine.js, Vanilla.js, or Hotwire
 CSS: Tailwind, DaisyUI, or Bootstrap
  
Plus, it includes auto-reload in development - no more manual refreshing when you edit code!
 React, Vue support will come soon!
 Hope it can help developers here.
 Link: https://saashammer.com/blog/django-vite-boilerplate/
    submitted by    /u/Michaelyin  
 [link]   [comments]

Supercharge Your Django Frontend with Vite: A Modern Boilerplate

<div class="md">What platforms do you guys deploy your backend/django APIs on nowadays. For me It used to be Heroku for the serve and DB in one place but ive been enjoying Neon and Railway more lately. Curious to hear what you guys use. </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/Kolosafo"> /u/Kolosafo </a> <a href="https://www.reddit.com/r/django/comments/1qhycex/where_do_you_deploy_your_apis_nowadays/">[link]</a> &#32; <a href="https://www.reddit.com/r/django/comments/1qhycex/where_do_you_deploy_your_apis_nowadays/">[comments]</a>

What platforms do you guys deploy your backend/django APIs on nowadays. For me It used to be Heroku for the serve and DB in one place but ive been enjoying Neon and Railway more lately. Curious to hear what you guys use.
    submitted by    /u/Kolosafo  
 [link]   [comments]

Where do you deploy your APIs nowadays?

<div class="md">iommi recently passed 1000 stars on GitHub! Since last: <ul> <li>New drag &amp; drop file uploader</li> <li>MainMenu promoted from experimental to stable</li> <li>Disable sorting by default on non-model columns</li> <li>Improved FBV support</li> <li>Default names for MainMenu items, useful for reverse/{% url %}</li> </ul> Plus a bunch of minor improvements and bug fixes. Check out iommi at <a href="https://github.com/iommirocks/iommi">https://github.com/iommirocks/iommi</a> and <a href="https://iommi.rocks/">https://iommi.rocks/</a> </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/kankyo"> /u/kankyo </a> <a href="https://www.reddit.com/r/django/comments/1qh2tnk/iommi_7221_released/">[link]</a> &#32; <a href="https://www.reddit.com/r/django/comments/1qh2tnk/iommi_7221_released/">[comments]</a>

iommi recently passed 1000 stars on GitHub!
 Since last:
  
New drag & drop file uploader
 MainMenu promoted from experimental to stable
 Disable sorting by default on non-model columns
 Improved FBV support
 Default names for MainMenu items, useful for reverse/{% url %}
  
Plus a bunch of minor improvements and bug fixes. Check out iommi at https://github.com/iommirocks/iommi and https://iommi.rocks/
    submitted by    /u/kankyo  
 [link]   [comments]

iommi 7.22.1 released

<div class="md">Just released django-safe-migrations, an open-source static analyzer that checks Django migrations for patterns that can cause production issues. What it catches: <ul> <li>Adding NOT NULL columns without a default (fails on existing rows)</li> <li>Index creation without <code>CONCURRENTLY</code> on PostgreSQL (locks writes)</li> <li><code>AddIndexConcurrently</code> inside atomic migrations (will error)</li> <li>Dropping columns while old code still references them</li> <li>Using SQL reserved keywords like <code>order</code> or <code>type</code> as column names</li> <li>And 14 more patterns</li> </ul> Usage: <pre><code>pip install django-safe-migrations python manage.py check_migrations </code></pre> Output: <pre><code>myapp/0002_add_status.py ERROR [SM001] Adding NOT NULL field &#39;status&#39; without a default value. This will fail on tables with existing rows. Fix: Add a default value, or split into three migrations: 1. Add field as nullable 2. Backfill existing rows 3. Add NOT NULL constraint </code></pre> CI Integration: <pre><code># .pre-commit-config.yaml repos: - repo: https://github.com/YasserShkeir/django-safe-migrations rev: v0.3.0 hooks: - id: check-migrations </code></pre> Also supports JSON output for CI and SARIF for GitHub Code Scanning. Configuration: Rules can be disabled globally, by category, or per-app: <pre><code>SAFE_MIGRATIONS = { &quot;DISABLED_RULES&quot;: [&quot;SM006&quot;], &quot;DISABLED_CATEGORIES&quot;: [&quot;informational&quot;], &quot;APP_RULES&quot;: { &quot;legacy_app&quot;: {&quot;DISABLED_RULES&quot;: [&quot;SM002&quot;]} } } </code></pre> Or inline with comments: <pre><code>migrations.RemoveField( # safe-migrations: ignore SM002 model_name=&#39;user&#39;, name=&#39;old_field&#39;, ) </code></pre> <ul> <li>GitHub: <a href="https://github.com/YasserShkeir/django-safe-migrations">https://github.com/YasserShkeir/django-safe-migrations</a></li> <li>Docs: <a href="https://django-safe-migrations.readthedocs.io/en/latest/support/">https://django-safe-migrations.readthedocs.io/en/latest/support/</a></li> <li>PyPI: <a href="https://pypi.org/project/django-safe-migrations/">https://pypi.org/project/django-safe-migrations/</a></li> </ul> </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/TheCodingTutor"> /u/TheCodingTutor </a> <a href="https://www.reddit.com/r/django/comments/1qht2aq/djangosafemigrations_static_analyzer_to_catch/">[link]</a> &#32; <a href="https://www.reddit.com/r/django/comments/1qht2aq/djangosafemigrations_static_analyzer_to_catch/">[comments]</a>

Just released django-safe-migrations, an open-source static analyzer that checks Django migrations for patterns that can cause production issues.
 What it catches:
  
Adding NOT NULL columns without a default (fails on existing rows)
 Index creation without CONCURRENTLY on PostgreSQL (locks writes)
 AddIndexConcurrently inside atomic migrations (will error)
 Dropping columns while old code still references them
 Using SQL reserved keywords like order or type as column names
 And 14 more patterns
  
Usage:
 pip install django-safe-migrations python manage.py check_migrations 
 Output:
 myapp/0002_add_status.py ERROR [SM001] Adding NOT NULL field 'status' without a default value. This will fail on tables with existing rows. Fix: Add a default value, or split into three migrations: 1. Add field as nullable 2. Backfill existing rows 3. Add NOT NULL constraint 
 CI Integration:
 # .pre-commit-config.yaml repos: - repo: https://github.com/YasserShkeir/django-safe-migrations rev: v0.3.0 hooks: - id: check-migrations 
 Also supports JSON output for CI and SARIF for GitHub Code Scanning.
 Configuration:
 Rules can be disabled globally, by category, or per-app:
 SAFE_MIGRATIONS = { "DISABLED_RULES": ["SM006"], "DISABLED_CATEGORIES": ["informational"], "APP_RULES": { "legacy_app": {"DISABLED_RULES": ["SM002"]} } } 
 Or inline with comments:
 migrations.RemoveField( # safe-migrations: ignore SM002 model_name='user', name='old_field', ) 
  
GitHub: https://github.com/YasserShkeir/django-safe-migrations
 Docs: https://django-safe-migrations.readthedocs.io/en/latest/support/
 PyPI: https://pypi.org/project/django-safe-migrations/
  
   submitted by    /u/TheCodingTutor  
 [link]   [comments]

django-safe-migrations: Static analyzer to catch unsafe migrations before they hit production

<div class="md">I&#39;m a Python/Django Full-stack developer with 5+ years of experience. For the last four years, I&#39;ve been working on both open-source and private projects. I have worked with plenty of technologies as well, including Wagtail CMS, HTMX, Alpine.js, Next.js, etc. My github profile is also not that bad. Recently, I&#39;ve been looking for a new job, but it looks like I&#39;m doing something wrong, or the market has changed a lot. I am not able to find as many good jobs as it used to be in the market. Btw, I am open to both part-time and full-time, and also open to learn/adapting any new technology. What else would you suggest I learn to get hired quickly? My github: <a href="https://github.com/sandeepsajan0">https://github.com/sandeepsajan0</a> and my site: <a href="https://sandeepchauhansite.com/">https://sandeepchauhansite.com/</a> </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/Interesting_Crab_197"> /u/Interesting_Crab_197 </a> <a href="https://www.reddit.com/r/django/comments/1qg80qc/what_would_you_suggest_to_learn_to_get_hired_in/">[link]</a> &#32; <a href="https://www.reddit.com/r/django/comments/1qg80qc/what_would_you_suggest_to_learn_to_get_hired_in/">[comments]</a>

I'm a Python/Django Full-stack developer with 5+ years of experience. For the last four years, I've been working on both open-source and private projects. I have worked with plenty of technologies as well, including Wagtail CMS, HTMX, Alpine.js, Next.js, etc. My github profile is also not that bad. Recently, I've been looking for a new job, but it looks like I'm doing something wrong, or the market has changed a lot. I am not able to find as many good jobs as it used to be in the market. Btw, I am open to both part-time and full-time, and also open to learn/adapting any new technology.
 What else would you suggest I learn to get hired quickly?
 My github: https://github.com/sandeepsajan0 and my site: https://sandeepchauhansite.com/
    submitted by    /u/Interesting_Crab_197  
 [link]   [comments]

What would you suggest to learn to get hired in 2026 with Django?

<div class="md">I&#39;ve been using Django in production for several backend-intensive applications (such as API development, backend tasks, scheduled tasks, and some real-time features). What strikes me is how deployment considerations tend to influence architecture decisions sooner rather than later. The Django framework itself has been rock-solid for business logic, ORM, authentication, admin interface, etc., but beyond a simple &quot;serve a web page in response to a web request,&quot; other issues become important: worker processes, cron, etc., as well as predictability of cost. A few observations from recent projects: In a project involving - It is much easier to reason about Django services that are constantly online if background tasks and periodic jobs become central to the app. - Distributed management of web services, workers, and scheduled tasks can add management overhead for small teams - Hosting models as well as pricing models tend to have more influence on architectural decisions than we would like to admit. I&#39;ve used persistent compute models like gunicorn and ASGI when needed, and more recently experimented with backend-first platforms like seenode that allow web apps, workers, and databases to coexist with predictable costs. Not necessarily one approach being more suitable than another. Curious how others here approach this: - What are you currently using Django with in terms of production deployment? - How do you handle background tasks and Cron jobs? Have hosting or cost issues ever influenced your application structure with Django? Would love to hear real-world setups and lessons learned. </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/1qlvv8c/django_in_production_lessons_learned_from/">[link]</a> &#32; <a href="https://www.reddit.com/r/django/comments/1qlvv8c/django_in_production_lessons_learned_from/">[comments]</a>

I've been using Django in production for several backend-intensive applications (such as API development, backend tasks, scheduled tasks, and some real-time features). What strikes me is how deployment considerations tend to influence architecture decisions sooner rather than later. 
 The Django framework itself has been rock-solid for business logic, ORM, authentication, admin interface, etc., but beyond a simple "serve a web page in response to a web request," other issues become important: worker processes, cron, etc., as well as predictability of cost. 
 A few observations from recent projects:
  In a project involving 
 - It is much easier to reason about Django services that are constantly online if background tasks and periodic jobs become central to the app. 
 - Distributed management of web services, workers, and scheduled tasks can add management overhead for small teams 
 - Hosting models as well as pricing models tend to have more influence on architectural decisions than we would like to admit. 
 I've used persistent compute models like gunicorn and ASGI when needed, and more recently experimented with backend-first platforms like seenode that allow web apps, workers, and databases to coexist with predictable costs. Not necessarily one approach being more suitable than another. 
 Curious how others here approach this: 
 - What are you currently using Django with in terms of production deployment? 
 - How do you handle background tasks and Cron jobs? 
 Have hosting or cost issues ever influenced your application structure with Django? Would love to hear real-world setups and lessons learned.
    submitted by    /u/Away_Parsnip6783  
 [link]   [comments]

Django in production: Lessons learned from deploying "backend-heavy" apps

<div class="md">Hey everyone, I&#39;ve been building job board aggregators for a while, and the most painful part was always the data ingestion. I started like everyone else: writing simple <code>BeautifulSoup</code> scripts. Then the sites added JavaScript rendering, so I switched to <code>Selenium</code>. Then they added Cloudflare and IP bans, and I spent more time fixing broken selectors than actually building features. So, I decided to over-engineer a solution and turn it into a proper API. I just launched TechJobsData to solve this permanently. The Tech Stack: I wanted this to be robust, so I moved away from fragile cron jobs. <ul> <li>Backend: Python &amp; Django (DRF for the API endpoints).</li> <li>Scraping Engine: Scrapy (much faster/lighter than Selenium).</li> <li>Task Queue: Celery + Redis. I have a periodic task that triggers spiders for LinkedIn, Indeed, Glassdoor, and specialized remote boards (WeWorkRemotely, RemoteOK) every few hours.</li> <li>Infrastructure: Docker &amp; PostgreSQL.</li> </ul> The Hardest Technical Challenges: <ol> <li>Anti-Bot Systems: Getting past Cloudflare on sites like Indeed was a nightmare. I had to implement heavy middleware for User-Agent rotation and residential proxies to avoid 403s.</li> <li>Data Normalization: &quot;Senior Python Dev&quot; on one site is &quot;Sr. Backend Engineer (Python)&quot; on another. I built a normalization layer to clean up titles, salaries, and locations into a standardized JSON format.</li> <li>Throttling: I implemented custom Django throttling classes to handle different tiers (Free vs. Paid) so one user doesn&#39;t crash the DB.</li> </ol> The Result: A simple REST API that returns clean, JSON-formatted job data. You can filter by skill (e.g., &quot;Python&quot;, &quot;React&quot;) or location. Try it out: I made a Free Tier (20 requests per day) specifically for developers who want to play around with the data for their own side projects or AI models. No credit card needed. URL:<a href="https://techjobsdata.com">techjobsdata</a> I’d love to hear your feedback on the API structure or how you handle scraping at scale! </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/v3ski4a"> /u/v3ski4a </a> <a href="https://www.reddit.com/r/django/comments/1qjzd9k/i_built_an_api_to_scrape_remote_tech_jobs_because/">[link]</a> &#32; <a href="https://www.reddit.com/r/django/comments/1qjzd9k/i_built_an_api_to_scrape_remote_tech_jobs_because/">[comments]</a>

Hey everyone,
 I've been building job board aggregators for a while, and the most painful part was always the data ingestion.
 I started like everyone else: writing simple BeautifulSoup scripts. Then the sites added JavaScript rendering, so I switched to Selenium. Then they added Cloudflare and IP bans, and I spent more time fixing broken selectors than actually building features.
 So, I decided to over-engineer a solution and turn it into a proper API. I just launched TechJobsData to solve this permanently.
 The Tech Stack: I wanted this to be robust, so I moved away from fragile cron jobs.
  
Backend: Python & Django (DRF for the API endpoints).
 Scraping Engine: Scrapy (much faster/lighter than Selenium).
 Task Queue: Celery + Redis. I have a periodic task that triggers spiders for LinkedIn, Indeed, Glassdoor, and specialized remote boards (WeWorkRemotely, RemoteOK) every few hours.
 Infrastructure: Docker & PostgreSQL.
  
The Hardest Technical Challenges:
  
Anti-Bot Systems: Getting past Cloudflare on sites like Indeed was a nightmare. I had to implement heavy middleware for User-Agent rotation and residential proxies to avoid 403s.
 Data Normalization: "Senior Python Dev" on one site is "Sr. Backend Engineer (Python)" on another. I built a normalization layer to clean up titles, salaries, and locations into a standardized JSON format.
 Throttling: I implemented custom Django throttling classes to handle different tiers (Free vs. Paid) so one user doesn't crash the DB.
  
The Result: A simple REST API that returns clean, JSON-formatted job data. You can filter by skill (e.g., "Python", "React") or location.
 Try it out: I made a Free Tier (20 requests per day) specifically for developers who want to play around with the data for their own side projects or AI models. No credit card needed.
 URL:techjobsdata
 I’d love to hear your feedback on the API structure or how you handle scraping at scale!
    submitted by    /u/v3ski4a  
 [link]   [comments]

I built an API to scrape remote tech jobs because I was tired of my Selenium scripts breaking every week.

<div class="md">Hi everyone, I’m still pretty early in my career, so I’ve been trying to learn Django and backend system design by building complete projects instead of only following tutorials. I recently finished a project where I built a document semantic search engine with: <ul> <li>Django + HTMX for a server-driven UI</li> <li>Celery + Redis for background ingestion</li> <li>Qdrant as the vector database</li> <li>Hybrid keyword + semantic search</li> <li>Document similarity and explainability panels</li> <li>Re-indexing pipelines, progress bars, and search analytics</li> </ul> The main goal was to understand how real-world RAG-style systems are put together: chunking strategies, embedding orchestration, vector indexing, retrieval, and observability. I’d genuinely appreciate any feedback from experienced Django devs: <ul> <li>Does the overall architecture make sense?</li> <li>Are there parts you’d structure differently?</li> <li>Anything that stands out as over-engineered or under-engineered?</li> </ul> Here is the repo <a href="https://github.com/helios51193/document_search_engine">https://github.com/helios51193/document_search_engine</a> — thanks for reading! </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/big_haptun777"> /u/big_haptun777 </a> <a href="https://www.reddit.com/r/django/comments/1qkxocz/built_a_django_semantic_search_app_with_qdrant/">[link]</a> &#32; <a href="https://www.reddit.com/r/django/comments/1qkxocz/built_a_django_semantic_search_app_with_qdrant/">[comments]</a>

Hi everyone,
 I’m still pretty early in my career, so I’ve been trying to learn Django and backend system design by building complete projects instead of only following tutorials.
 I recently finished a project where I built a document semantic search engine with:
  
Django + HTMX for a server-driven UI
 Celery + Redis for background ingestion
 Qdrant as the vector database
 Hybrid keyword + semantic search
 Document similarity and explainability panels
 Re-indexing pipelines, progress bars, and search analytics
  
The main goal was to understand how real-world RAG-style systems are put together: chunking strategies, embedding orchestration, vector indexing, retrieval, and observability.
 I’d genuinely appreciate any feedback from experienced Django devs:
  
Does the overall architecture make sense?
 Are there parts you’d structure differently?
 Anything that stands out as over-engineered or under-engineered?
  
Here is the repo https://github.com/helios51193/document_search_engine — thanks for reading! 
    submitted by    /u/big_haptun777  
 [link]   [comments]

Built a Django semantic search app with Qdrant & Celery — would love feedback

<div class="md">Hello! I am trying to choose between DRF and ninja, and I see a lot of comments mentioning that ninja is for when you need async, without elaboration. I don&#39;t understand why I wouldn&#39;t need async, and most of all, I don&#39;t understand how DRF can even be an option without async. Surely, I don&#39;t understand what people mean by &quot;async&quot;. Let&#39;s suppose somebody is doing something very basic, like querying their user profile. Django will have to fetch the profile in the database. So if I use an option that does not support async, will Django just do nothing while it waits for the answer from the database? If other people are making requests, does that mean Django won&#39;t start processing any of them before the database gives an answer? Is that really what it means? Sounds like a very big deal to me, even for a small project. Thank you </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/jf8204"> /u/jf8204 </a> <a href="https://www.reddit.com/r/django/comments/1qh871c/drf_vs_ninja_what_is_that_async_thing_about/">[link]</a> &#32; <a href="https://www.reddit.com/r/django/comments/1qh871c/drf_vs_ninja_what_is_that_async_thing_about/">[comments]</a>

Hello!
 I am trying to choose between DRF and ninja, and I see a lot of comments mentioning that ninja is for when you need async, without elaboration. I don't understand why I wouldn't need async, and most of all, I don't understand how DRF can even be an option without async. Surely, I don't understand what people mean by "async".
 Let's suppose somebody is doing something very basic, like querying their user profile. Django will have to fetch the profile in the database. So if I use an option that does not support async, will Django just do nothing while it waits for the answer from the database? If other people are making requests, does that mean Django won't start processing any of them before the database gives an answer? Is that really what it means? Sounds like a very big deal to me, even for a small project.
 Thank you
    submitted by    /u/jf8204  
 [link]   [comments]

DRF vs ninja: What is that "async" thing about?

<div class="md">Expectation: &quot;If I add zh-cn, I&#39;ll get millions of Chinese users!&quot; Reality: 100+ new visitors from China... all Desktop, 100% bounce rate. Hello, Baidu Spiders! 🕷️ At least my sitemap.xml is working perfectly. Has anyone else experienced a bot explosion after adding i18n support? How do you filter this in GA4 to see real users? </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/Thank_Japan"> /u/Thank_Japan </a> <a href="https://www.reddit.com/gallery/1qfz9zn">[link]</a> &#32; <a href="https://www.reddit.com/r/django/comments/1qfz9zn/i_added_simplified_chinese_zhcn_support_to_my/">[comments]</a>

Expectation: "If I add zh-cn, I'll get millions of Chinese users!"
 Reality: 100+ new visitors from China... all Desktop, 100% bounce rate. Hello, Baidu Spiders! 🕷️
 At least my sitemap.xml is working perfectly.
 Has anyone else experienced a bot explosion after adding i18n support? How do you filter this in GA4 to see real users?
    submitted by    /u/Thank_Japan  
 [link]   [comments]

I added Simplified Chinese (zh-cn) support to my Django app, and... well, the Baidu bots love it.

<div class="md">I&#39;m over a year into my first project and I want to convert to a custom user model so that I can protect user emails at rest (probably by hashing). Protecting emails is important so that we can meet GDPR compliance. I don&#39;t know whether I need to flush the database while we are small to make this happen. The migration seems very tricky. I&#39;ve also seen there are some workarounds to consider but I feel like now is the best time to convert as we have a pretty small userbase. What are my options here? EDIT: Got the job done. I highly recommend the following guide/article, it is quite simple. Follow the guide carefully, run thorough staging tests and have a backup plan. I tested on staging with a copy of the prod DB before deploying to prod: <a href="https://www.caktusgroup.com/blog/2019/04/26/how-switch-custom-django-user-model-mid-project/">https://www.caktusgroup.com/blog/2019/04/26/how-switch-custom-django-user-model-mid-project/</a> </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/EvilDoctorShadex"> /u/EvilDoctorShadex </a> <a href="https://www.reddit.com/r/django/comments/1qjb1u5/heeelp_converting_to_custom_user_model_midproject/">[link]</a> &#32; <a href="https://www.reddit.com/r/django/comments/1qjb1u5/heeelp_converting_to_custom_user_model_midproject/">[comments]</a>

I'm over a year into my first project and I want to convert to a custom user model so that I can protect user emails at rest (probably by hashing).
 Protecting emails is important so that we can meet GDPR compliance.
 I don't know whether I need to flush the database while we are small to make this happen. The migration seems very tricky.
 I've also seen there are some workarounds to consider but I feel like now is the best time to convert as we have a pretty small userbase.
 What are my options here?
 EDIT: Got the job done. I highly recommend the following guide/article, it is quite simple. Follow the guide carefully, run thorough staging tests and have a backup plan. I tested on staging with a copy of the prod DB before deploying to prod:
 https://www.caktusgroup.com/blog/2019/04/26/how-switch-custom-django-user-model-mid-project/
    submitted by    /u/EvilDoctorShadex  
 [link]   [comments]

Heeelp! Converting to Custom User Model Mid-Project

<div class="md">We run a legal directory and search platform. We are adding: <ul> <li>User authentication &amp; login (Django auth/allauth)</li> <li>Stripe subscription billing (checkout + webhooks + plans)</li> <li>Firm dashboard (manage subscriptions)</li> <li>Editable firm profile content (structured fields + approvals)</li> <li>Admin moderation tools</li> </ul> You should have proven experience building subscriptions in Django with Stripe, clean REST/HTML work, secure role-based access, and deployment experience. </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/dragfest"> /u/dragfest </a> <a href="https://www.reddit.com/r/django/comments/1qiw1cb/django_developer_for_online_directory_logins_for/">[link]</a> &#32; <a href="https://www.reddit.com/r/django/comments/1qiw1cb/django_developer_for_online_directory_logins_for/">[comments]</a>

We run a legal directory and search platform. We are adding:
  
User authentication & login (Django auth/allauth)
 Stripe subscription billing (checkout + webhooks + plans)
 Firm dashboard (manage subscriptions)
 Editable firm profile content (structured fields + approvals)
 Admin moderation tools
  
You should have proven experience building subscriptions in Django with Stripe, clean REST/HTML work, secure role-based access, and deployment experience.
    submitted by    /u/dragfest  
 [link]   [comments]

Django Developer for online directory — Logins for businesses listed on the directory + Stripe Subscriptions + Profile Editing

<div class="md">In case that anyone here follows closely enough the development of Django, specifically the integration of asynchronous calls in the ORM, would you be able to elaborate on the actual status of it and its roadmap? I am developing a REST API using Django Ninja and using the ORM to access a PostgreSQL database. The question I would like to know the answer to is how many async features have already been implemented and how many are pending. I know there are a lot of async methods to use the ORM, which I am using, but I&#39;ve read here and there that they are just wrappers. And the more I read, the more confusing it gets, as I don&#39;t know whether the whole &quot;trying to make it all async&quot; [1]is really worth the effort. For me, even if it is just as an investment that will have to wait for a couple more major releases, then it is worth it. But I would like to actually know. [1]: Database driver, ORM calls, test client, logging, access to Redis/Valkey csche, etc. Anything else? </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/jsabater76"> /u/jsabater76 </a> <a href="https://www.reddit.com/r/django/comments/1qidvuv/async_access_to_orm_in_django_6x/">[link]</a> &#32; <a href="https://www.reddit.com/r/django/comments/1qidvuv/async_access_to_orm_in_django_6x/">[comments]</a>

In case that anyone here follows closely enough the development of Django, specifically the integration of asynchronous calls in the ORM, would you be able to elaborate on the actual status of it and its roadmap?
 I am developing a REST API using Django Ninja and using the ORM to access a PostgreSQL database. The question I would like to know the answer to is how many async features have already been implemented and how many are pending.
 I know there are a lot of async methods to use the ORM, which I am using, but I've read here and there that they are just wrappers.
 And the more I read, the more confusing it gets, as I don't know whether the whole "trying to make it all async" [1]is really worth the effort.
 For me, even if it is just as an investment that will have to wait for a couple more major releases, then it is worth it. But I would like to actually know.
 [1]: Database driver, ORM calls, test client, logging, access to Redis/Valkey csche, etc. Anything else?
    submitted by    /u/jsabater76  
 [link]   [comments]

Async access to ORM in Django 6.x

<div class="md">hello folks, so there&#39;s this project that I&#39;m working on. Let me tell you that it&#39;s an absolute mess.. single views.py growing close to 14k lines.. so many models.. it&#39;s a pretty big project.. now my TL and manager are behind me to make a plan for refactoring the entire project.. I&#39;m kinda lost.. honestly, it&#39;s a pain to work on it but more than that it becomes a nightmare if you don&#39;t change the code carefully.. like code is just spilling over everywhere.. and i know it&#39;ll need thorough testing.. do you think i should consider this? honestly it&#39;s a challenge for me as mid-senior swe.. What are your suggestions? is there any tool that can help me? Maybe AI tools? </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/meet-me-piya"> /u/meet-me-piya </a> <a href="https://www.reddit.com/r/django/comments/1qh6t0b/rewrite_project_in_modular_way_or_leave_it/">[link]</a> &#32; <a href="https://www.reddit.com/r/django/comments/1qh6t0b/rewrite_project_in_modular_way_or_leave_it/">[comments]</a>

hello folks, so there's this project that I'm working on. Let me tell you that it's an absolute mess.. single views.py growing close to 14k lines.. so many models.. it's a pretty big project.. now my TL and manager are behind me to make a plan for refactoring the entire project.. I'm kinda lost.. honestly, it's a pain to work on it but more than that it becomes a nightmare if you don't change the code carefully.. like code is just spilling over everywhere.. and i know it'll need thorough testing.. do you think i should consider this? honestly it's a challenge for me as mid-senior swe.. What are your suggestions? is there any tool that can help me? Maybe AI tools? 
    submitted by    /u/meet-me-piya  
 [link]   [comments]

Rewrite project in modular way or leave it?

&#32; submitted by &#32; <a href="https://www.reddit.com/user/dwaxe"> /u/dwaxe </a> <a href="https://www.djangoproject.com/weblog/2026/jan/21/djangonaut-space-session-6-accepting-applications/">[link]</a> &#32; <a href="https://www.reddit.com/r/django/comments/1qj5q9u/djangonaut_space_session_6_accepting_applications/">[comments]</a>

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

Djangonaut Space - Session 6 Accepting Applications

<div class="md">A couple weeks ago I posted about TranslateBot ( <a href="https://github.com/gettranslatebot/translatebot-django">https://github.com/gettranslatebot/translatebot-django</a> ), my &quot;please stop making me copy/paste into Google Translate&quot; open source library for Django .po filse. Since then I’ve been shipping fixes pretty quickly, and a bunch of the rough edges are now gone. Here are the highlights from the last ~2 weeks of releases: What is new / improved Much more resilient LLM calls <ul> <li>Automatic retries with exponential backoff on rate limits of LLM provider (429)</li> <li>Clearer error messages when you’re out of credits / have auth issues (instead of cryptic tracebacks)</li> </ul> Better correctness for real-world PO files <ul> <li>Fuzzy entries are now properly re-translated (and the fuzzy flag gets cleared after).</li> <li>Fixes for language/locale edge cases like zh-hans (Traditional Chinese)</li> </ul> JSON output parsing is harder to break <ul> <li>Handles models that add “Here is the translation:” before the JSON (or models that wrap it in json code fences)</li> <li>Fixed a rare but painful issue where the model returns fewer translations than inputs</li> </ul> Workflow is still the same, you can check out the project here: <a href="https://translatebot.dev/">https://translatebot.dev/</a> <pre><code>uv add translatebot-django --dev ./manage.py makemessages -l fr ./manage.py translate --target-lang fr </code></pre> </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/leipegokker"> /u/leipegokker </a> <a href="https://www.reddit.com/r/django/comments/1qkkosy/translatebot_got_a_bunch_of_upgrades/">[link]</a> &#32; <a href="https://www.reddit.com/r/django/comments/1qkkosy/translatebot_got_a_bunch_of_upgrades/">[comments]</a>

A couple weeks ago I posted about TranslateBot ( https://github.com/gettranslatebot/translatebot-django ), my "please stop making me copy/paste into Google Translate" open source library for Django .po filse.
 Since then I’ve been shipping fixes pretty quickly, and a bunch of the rough edges are now gone. Here are the highlights from the last ~2 weeks of releases:
 What is new / improved 
 Much more resilient LLM calls
  
Automatic retries with exponential backoff on rate limits of LLM provider (429)
 Clearer error messages when you’re out of credits / have auth issues (instead of cryptic tracebacks)
  
Better correctness for real-world PO files
  
Fuzzy entries are now properly re-translated (and the fuzzy flag gets cleared after).
 Fixes for language/locale edge cases like zh-hans (Traditional Chinese)
  
JSON output parsing is harder to break
  
Handles models that add “Here is the translation:” before the JSON (or models that wrap it in json code fences)
 Fixed a rare but painful issue where the model returns fewer translations than inputs
  
Workflow is still the same, you can check out the project here: https://translatebot.dev/
 uv add translatebot-django --dev ./manage.py makemessages -l fr ./manage.py translate --target-lang fr 
    submitted by    /u/leipegokker  
 [link]   [comments]

TranslateBot got a bunch of upgrades 🚀

<div class="md">Hey everyone, A few months ago I shared AIWAF, a Django-native web application firewall that adapts to real traffic using rate limiting, anomaly detection, dynamic keywords, and honeypots. I wanted to share a small but useful update. Geo-blocking is now available. It works by resolving client IPs against a local GeoIP database and caching results via Django’s cache framework. There are no per-request external API calls, and if GeoIP or cache isn’t available, it fails safely (geo-blocking simply becomes a no-op). How it behaves (high level): <ul> <li>Uses a local .mmdb GeoIP database</li> <li>Caches country lookups to keep overhead low</li> <li>Falls back gracefully if GeoIP or cache is unavailable</li> <li>Fully optional and works alongside existing AIWAF protections</li> <li>Designed for app-layer use cases where route/context awareness matters</li> </ul> This isn’t meant to replace edge-level WAFs, but to cover cases where people want geographic controls inside a Django app (self-hosted apps, internal tools, compliance constraints, etc.). <a href="https://pypi.org/project/aiwaf/">aiwaf · PyPI</a> Feedback welcome, especially around GeoIP edge cases or defaults you’ve found reasonable in production. </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/Mediocre_Scallion_99"> /u/Mediocre_Scallion_99 </a> <a href="https://www.reddit.com/r/django/comments/1qjftge/aiwaf_django_update_geoblocking_using_local_geoip/">[link]</a> &#32; <a href="https://www.reddit.com/r/django/comments/1qjftge/aiwaf_django_update_geoblocking_using_local_geoip/">[comments]</a>

Hey everyone,
 A few months ago I shared AIWAF, a Django-native web application firewall that adapts to real traffic using rate limiting, anomaly detection, dynamic keywords, and honeypots. I wanted to share a small but useful update.
 Geo-blocking is now available.
 It works by resolving client IPs against a local GeoIP database and caching results via Django’s cache framework. There are no per-request external API calls, and if GeoIP or cache isn’t available, it fails safely (geo-blocking simply becomes a no-op).
 How it behaves (high level):
  
Uses a local .mmdb GeoIP database
 Caches country lookups to keep overhead low
 Falls back gracefully if GeoIP or cache is unavailable
 Fully optional and works alongside existing AIWAF protections
 Designed for app-layer use cases where route/context awareness matters
  
This isn’t meant to replace edge-level WAFs, but to cover cases where people want geographic controls inside a Django app (self-hosted apps, internal tools, compliance constraints, etc.).
 aiwaf · PyPI
 Feedback welcome, especially around GeoIP edge cases or defaults you’ve found reasonable in production.
    submitted by    /u/Mediocre_Scallion_99  
 [link]   [comments]

AIWAF (Django) update: Geo-blocking using local GeoIP with caching (no external APIs)

<div class="md">Anyone in this group has been to GSOC of Django? Need guide... </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/Fragrant_Refuse506"> /u/Fragrant_Refuse506 </a> <a href="https://www.reddit.com/r/django/comments/1qhcff1/django_gsoc/">[link]</a> &#32; <a href="https://www.reddit.com/r/django/comments/1qhcff1/django_gsoc/">[comments]</a>

Anyone in this group has been to GSOC of Django? Need guide...
    submitted by    /u/Fragrant_Refuse506  
 [link]   [comments]

Django GSOC

<div class="md">Looking for feedback 🙂 <blockquote> <code>django-returns</code> is a tiny layer on top of Django’s ORM that lets you opt into <code>returns</code> containers when you want explicit success/failure return types instead of exceptions. </blockquote> </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/poopatroopa3"> /u/poopatroopa3 </a> <a href="https://brunodantas.github.io/django-returns">[link]</a> &#32; <a href="https://www.reddit.com/r/django/comments/1qi2jmi/djangoreturns_meaningful_django_utils_based_on/">[comments]</a>

Looking for feedback 🙂
  
django-returns is a tiny layer on top of Django’s ORM that lets you opt into returns containers when you want explicit success/failure return types instead of exceptions.
  
   submitted by    /u/poopatroopa3  
 [link]   [comments]

Hello, Python

Python Jobs 💼