<div class="md">I am seeing these kind of jobs everywhere in my linkedin. </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/Kraven_Holmes"> /u/Kraven_Holmes </a> <a href="https://i.redd.it/crggertdqbtg1.jpeg">[link]</a> &#32; <a href="https://www.reddit.com/r/django/comments/1scxbzg/they_want_a_data_scientist_backend_dev_ml/">[comments]</a>

I am seeing these kind of jobs everywhere in my linkedin.
    submitted by    /u/Kraven_Holmes  
 [link]   [comments]

They want a data scientist + backend dev + ML engineer + DevOps person in one fresh graduate. 💀

<div class="md">This article explains how to implement real-time table filtering and data exporting in Django using <code>django-tables2</code> and HTMX, eliminating the need for custom JavaScript. By utilizing HTMX to partially update the page based on input changes, the approach achieves a fast user experience while keeping logic in the backend. </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/fundor333"> /u/fundor333 </a> <a href="https://fundor333.com/post/2026/django-table-filter-export-with-htmx/">[link]</a> &#32; <a href="https://www.reddit.com/r/django/comments/1sbggko/django_table_filter_and_export_with_htmx/">[comments]</a>

This article explains how to implement real-time table filtering and data exporting in Django using django-tables2 and HTMX, eliminating the need for custom JavaScript. By utilizing HTMX to partially update the page based on input changes, the approach achieves a fast user experience while keeping logic in the backend.
    submitted by    /u/fundor333  
 [link]   [comments]

Django Table, Filter and Export With Htmx

<div class="md">I’ve been working on a Django project to better understand knowledge graphs, LLM explainability, and document processing. The app lets you upload a document, process it asynchronously, build a graph from the extracted entities/relations, and then ask natural-language questions against that graph. Stack is mostly: <ul> <li>Django</li> <li>HTMX</li> <li>Celery + Redis</li> <li>Memgraph</li> <li>Cytoscape.js</li> <li>OpenAI / Ollama</li> </ul> A lot of the work ended up not being just “call an LLM and get an answer”, but all the messy parts around it: <ul> <li>chunking strategy</li> <li>coreference for relation extraction</li> <li>alias / duplicate entity merging</li> <li>graph quality issues like isolated nodes and fragmented components</li> <li>making the answers explainable instead of just plausible</li> </ul> So the QA side now shows: <ul> <li>the generated Cypher</li> <li>raw query rows</li> <li>provenance/source snippets</li> <li>question-analysis metadata</li> <li>graph highlighting for the relevant nodes/edges</li> </ul> I also added saved QA sessions per document, graph reloads on the QA page, processing logs, and a Docker setup so the whole thing is easier to run. This was mainly a learning project, but I wanted to build it in a way that still felt structured and extensible instead of just a quick prototype. GitHub: <a href="https://github.com/helios51193/knowledge-graph-qa">https://github.com/helios51193/knowledge-graph-qa</a> Would genuinely love feedback from Django folks, especially on the architecture / UX side. EDIT : Added type-hints and doc-strings. </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/1sce3gn/built_a_django_app_that_turns_documents_into_a/">[link]</a> &#32; <a href="https://www.reddit.com/r/django/comments/1sce3gn/built_a_django_app_that_turns_documents_into_a/">[comments]</a>

I’ve been working on a Django project to better understand knowledge graphs, LLM explainability, and document processing.
 The app lets you upload a document, process it asynchronously, build a graph from the extracted entities/relations, and then ask natural-language questions against that graph.
 Stack is mostly:
  
Django
 HTMX
 Celery + Redis
 Memgraph
 Cytoscape.js
 OpenAI / Ollama
  
A lot of the work ended up not being just “call an LLM and get an answer”, but all the messy parts around it:
  
chunking strategy
 coreference for relation extraction
 alias / duplicate entity merging
 graph quality issues like isolated nodes and fragmented components
 making the answers explainable instead of just plausible
  
So the QA side now shows:
  
the generated Cypher
 raw query rows
 provenance/source snippets
 question-analysis metadata
 graph highlighting for the relevant nodes/edges
  
I also added saved QA sessions per document, graph reloads on the QA page, processing logs, and a Docker setup so the whole thing is easier to run.
 This was mainly a learning project, but I wanted to build it in a way that still felt structured and extensible instead of just a quick prototype.
 GitHub: https://github.com/helios51193/knowledge-graph-qa
 Would genuinely love feedback from Django folks, especially on the architecture / UX side.
 EDIT : Added type-hints and doc-strings.
    submitted by    /u/big_haptun777  
 [link]   [comments]

Built a Django app that turns documents into a knowledge graph and lets you query it

<div class="md">i have learned the basics of Django and build projects use it. I want to say, what are the most powerful and important things should i learn to be better in this framework. Also, i want for you to share with me best project ideas can make to learn new things, i prefer the ideas to be different of each others. Thank you all. </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/Visible-Wrap-7729"> /u/Visible-Wrap-7729 </a> <a href="https://www.reddit.com/r/django/comments/1s9vrcl/django_advanced_conecpts/">[link]</a> &#32; <a href="https://www.reddit.com/r/django/comments/1s9vrcl/django_advanced_conecpts/">[comments]</a>

i have learned the basics of Django and build projects use it.
 I want to say, what are the most powerful and important things should i learn to be better in this framework.
 Also, i want for you to share with me best project ideas can make to learn new things, i prefer the ideas to be different of each others.
 Thank you all.
    submitted by    /u/Visible-Wrap-7729  
 [link]   [comments]

Django advanced conecpts

<div class="md">I’m fairly new to Django development and I want to experiment with Django to make a REST api. I looked into the usual suspects DRF, Django-Ninja and Django-bolt. Now i stumbled upon django-modern-rest. However I lack the experience to evaluate their solution. Anyone that can shed some light? Furthermore I find it difficult to pick a library for the creation of API’s. The landscape is really fragmented and I don’t want to invest time and energy in a library that won’t be supported and/or developed in the foreseeable future. There recently was another post and for new projects it appears that django-ninja is the way to go. But django-modern-rest is made by We Make Services which appears to be a well respected company. Hence why I would like some feedback on the project from more experienced developers. </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/MrN86"> /u/MrN86 </a> <a href="https://github.com/wemake-services/django-modern-rest">[link]</a> &#32; <a href="https://www.reddit.com/r/django/comments/1s7t8nk/djangomodernrest/">[comments]</a>

I’m fairly new to Django development and I want to experiment with Django to make a REST api. I looked into the usual suspects DRF, Django-Ninja and Django-bolt.
 Now i stumbled upon django-modern-rest. However I lack the experience to evaluate their solution. Anyone that can shed some light?
 Furthermore I find it difficult to pick a library for the creation of API’s. The landscape is really fragmented and I don’t want to invest time and energy in a library that won’t be supported and/or developed in the foreseeable future.
 There recently was another post and for new projects it appears that django-ninja is the way to go. But django-modern-rest is made by We Make Services which appears to be a well respected company. Hence why I would like some feedback on the project from more experienced developers.
    submitted by    /u/MrN86  
 [link]   [comments]

Django-modern-rest

<div class="md">I have been going back and forth for the last few weeks after my 8-5 shift trying to plan for a Multi-tenant SaaS I have a lot of questions, and I can&#39;t really be satisfied about any answers I would reach, I read articles, discussed with AIs, but I need advices based on real experience, if you can help <ol> <li>Is djang-tenants the way to go for that?</li> <li>Auth .. i would def use django auth instead of re-inventing the wheel, so should auth occurs on the tenant level or public leve? auth_users table would exist in every tenant schema?</li> <li>VIP Customers ... I was thinking about giving vip customers dedicated databases if they want to, and include the db connection in the public layer tenants table, then have a simple router to route the requests to this db when needed, what do you think of that approach?</li> </ol> I am sorry I am just lost and overwhelmed, if you have resources I am really open to read them </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/_khi4"> /u/_khi4 </a> <a href="https://www.reddit.com/r/django/comments/1sd643b/multitenant_saas_with_django/">[link]</a> &#32; <a href="https://www.reddit.com/r/django/comments/1sd643b/multitenant_saas_with_django/">[comments]</a>

I have been going back and forth for the last few weeks after my 8-5 shift trying to plan for a Multi-tenant SaaS
 I have a lot of questions, and I can't really be satisfied about any answers I would reach, I read articles, discussed with AIs, but I need advices based on real experience, if you can help
  
Is djang-tenants the way to go for that?
 
Auth .. i would def use django auth instead of re-inventing the wheel, so should auth occurs on the tenant level or public leve? auth_users table would exist in every tenant schema?
 
VIP Customers ... I was thinking about giving vip customers dedicated databases if they want to, and include the db connection in the public layer tenants table, then have a simple router to route the requests to this db when needed, what do you think of that approach?
 
 I am sorry I am just lost and overwhelmed, if you have resources I am really open to read them
    submitted by    /u/_khi4  
 [link]   [comments]

Multi-tenant SaaS with django

<div class="md">I&#39;ve been developing software privately for my own business since 2019 — so I come from the pre-AI coding era. When ChatGPT 3 dropped in 2022, it massively improved my skills. I no longer had to spend hours trial-and-erroring my way through library docs. I could interact with problems more directly and ship things way faster. Up until late 2025, I kept testing various AI coding agents — GitHub Copilot, Cursor, Claude Code, Augment Code. But it always followed the same pattern: I&#39;d go all-in, then pull back because more errors were introduced than value gained. In 2026, I gave Claude Code another serious shot. With Opus 4.5 and 4.6, plus some significant adjustments to my workflow, I&#39;m now getting consistently good results — without writing code myself. The key change was how I spend my time. I plan extensively with Claude Code now: discussing non-happy paths, thinking deeply about architecture, sometimes spending 1–2 hours per feature just on planning across multiple iterations. For critical code that absolutely cannot fail, I write pseudocode myself and then iterate further with Claude Code. My general workflow looks like this: <ol> <li>Plan the feature — long, multi-iteration discussions (1–2h per feature)</li> <li>Implementation — Claude Code writes the code</li> <li>Review — Claude Code review agents run on different issues, two passes</li> </ol> Do errors still happen? Of course. The AI gets lazy sometimes, picks lazy fallbacks, or drifts from instructions. But honestly, I&#39;d also make plenty of mistakes that the AI catches early. My question to you: Do you think I&#39;m making a mistake by moving to a coding workflow where I mainly prompt and write virtually no code myself? There seem to be two camps right now. One says this is the future. The other says it&#39;s a recipe for disaster. I&#39;ve always counted myself in the &quot;recipe for disaster&quot; camp — but I&#39;m getting the growing feeling that we&#39;re crossing a threshold right now where this is actually becoming practical. What&#39;s your take? **DISCLAIMER i enhanced the text with a LLM </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/Main-Position-2007"> /u/Main-Position-2007 </a> <a href="https://www.reddit.com/r/django/comments/1s8z762/your_opinion_on_full_ai_coding/">[link]</a> &#32; <a href="https://www.reddit.com/r/django/comments/1s8z762/your_opinion_on_full_ai_coding/">[comments]</a>

I've been developing software privately for my own business since 2019 — so I come from the pre-AI coding era.
 When ChatGPT 3 dropped in 2022, it massively improved my skills. I no longer had to spend hours trial-and-erroring my way through library docs. I could interact with problems more directly and ship things way faster.
 Up until late 2025, I kept testing various AI coding agents — GitHub Copilot, Cursor, Claude Code, Augment Code. But it always followed the same pattern: I'd go all-in, then pull back because more errors were introduced than value gained.
 In 2026, I gave Claude Code another serious shot. With Opus 4.5 and 4.6, plus some significant adjustments to my workflow, I'm now getting consistently good results — without writing code myself.
 The key change was how I spend my time. I plan extensively with Claude Code now: discussing non-happy paths, thinking deeply about architecture, sometimes spending 1–2 hours per feature just on planning across multiple iterations. For critical code that absolutely cannot fail, I write pseudocode myself and then iterate further with Claude Code.
 My general workflow looks like this:
  
Plan the feature — long, multi-iteration discussions (1–2h per feature)
 Implementation — Claude Code writes the code
 Review — Claude Code review agents run on different issues, two passes
  
Do errors still happen? Of course. The AI gets lazy sometimes, picks lazy fallbacks, or drifts from instructions. But honestly, I'd also make plenty of mistakes that the AI catches early.
 My question to you: Do you think I'm making a mistake by moving to a coding workflow where I mainly prompt and write virtually no code myself?
 There seem to be two camps right now. One says this is the future. The other says it's a recipe for disaster.
 I've always counted myself in the "recipe for disaster" camp — but I'm getting the growing feeling that we're crossing a threshold right now where this is actually becoming practical.
 What's your take?
 **DISCLAIMER i enhanced the text with a LLM 
    submitted by    /u/Main-Position-2007  
 [link]   [comments]

Your Opinion on Full AI Coding

<div class="md">Hello everyone 👋, A couple months ago I shared an early version of Cratos here. Got 24 stars and more useful feedback than I expected. People pointed out real gaps in the security model, the install experience was painful, and the UI was rough. This post is a follow-up to say thanks and show what came out of that feedback. For newcomers: Cratos is a self-hosted scheduling backend. Your app calls an API to register a job (a URL, a schedule, and a payload), and Cratos executes it at the right time by sending a webhook, with retries and execution history. No code runs inside Cratos, your business logic stays in your own services. I built it because I kept solving the same problem across projects: scheduling HTTP calls per user or per event, and there wasn’t a clean self-hosted solution focused specifically on that. What changed since the last version - UI : This was the biggest piece of feedback. The interface was fully rewritten with a cleaner layout. It now includes a dedicated task detail page with full execution history, exact timestamps, and per-run error inspection. - Server / Installation : Consolidated from multiple repos into one. Install is now two commands using Docker images on Docker Hub, no building from source. Execution history is more complete too: HTTP status, response body, duration, and error details per run. - Security : Two things that were flagged last time and rightfully so. Webhook signing with HMAC-SHA256 so your endpoints can verify every request came from Cratos. Origin allowlisting so callback URLs must be explicitly approved before Cratos will call them, enforced at request time to prevent SSRF. GitHub: <a href="https://github.com/Ghiles1010/Cratos">https://github.com/Ghiles1010/Cratos</a> I’m still very open to feedback 🙏, especially from anyone who tried v1 and ran into issues. </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/One-Meeting-921"> /u/One-Meeting-921 </a> <a href="https://www.reddit.com/gallery/1sd81pn">[link]</a> &#32; <a href="https://www.reddit.com/r/django/comments/1sd81pn/i_rebuilt_my_selfhosted_webhook_scheduler_cratos/">[comments]</a>

Hello everyone 👋,
 A couple months ago I shared an early version of Cratos here. Got 24 stars and more useful feedback than I expected. People pointed out real gaps in the security model, the install experience was painful, and the UI was rough. This post is a follow-up to say thanks and show what came out of that feedback.
 For newcomers: Cratos is a self-hosted scheduling backend. Your app calls an API to register a job (a URL, a schedule, and a payload), and Cratos executes it at the right time by sending a webhook, with retries and execution history. No code runs inside Cratos, your business logic stays in your own services. I built it because I kept solving the same problem across projects: scheduling HTTP calls per user or per event, and there wasn’t a clean self-hosted solution focused specifically on that.
 What changed since the last version
 - UI : This was the biggest piece of feedback. The interface was fully rewritten with a cleaner layout. It now includes a dedicated task detail page with full execution history, exact timestamps, and per-run error inspection.
 - Server / Installation : Consolidated from multiple repos into one. Install is now two commands using Docker images on Docker Hub, no building from source. Execution history is more complete too: HTTP status, response body, duration, and error details per run.
 - Security : Two things that were flagged last time and rightfully so. Webhook signing with HMAC-SHA256 so your endpoints can verify every request came from Cratos. Origin allowlisting so callback URLs must be explicitly approved before Cratos will call them, enforced at request time to prevent SSRF.
 GitHub: https://github.com/Ghiles1010/Cratos 
 I’m still very open to feedback 🙏, especially from anyone who tried v1 and ran into issues.
    submitted by    /u/One-Meeting-921  
 [link]   [comments]

I rebuilt my self-hosted webhook scheduler (Cratos) after your feedback

<div class="md">Hi everyone, I&#39;m a beginner in backend development, currently focusing on Django. I haven&#39;t landed my first job or done any professional work yet; my foundation is mostly built on online courses. Here is my biggest struggle right now: I often watch project tutorials on YouTube, and I completely understand the logic and what&#39;s going on. But the moment I try to start building a project on my own from scratch, my mind goes blank and I just get stuck. On top of that, I constantly find myself running into large, complex concepts (like architecture design, deployment, etc.) that feel overwhelming. How can I effectively break out of this &quot;tutorial hell&quot; and start building independently? How do I bridge the gap between just understanding a video and actually writing the code myself? </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/Om_JR"> /u/Om_JR </a> <a href="https://www.reddit.com/r/django/comments/1sdp3q0/beginner_in_djangobackend_i_understand_tutorials/">[link]</a> &#32; <a href="https://www.reddit.com/r/django/comments/1sdp3q0/beginner_in_djangobackend_i_understand_tutorials/">[comments]</a>

Hi everyone,
 I'm a beginner in backend development, currently focusing on Django. I haven't landed my first job or done any professional work yet; my foundation is mostly built on online courses.
 Here is my biggest struggle right now: I often watch project tutorials on YouTube, and I completely understand the logic and what's going on. But the moment I try to start building a project on my own from scratch, my mind goes blank and I just get stuck.
 On top of that, I constantly find myself running into large, complex concepts (like architecture design, deployment, etc.) that feel overwhelming.
 How can I effectively break out of this "tutorial hell" and start building independently? How do I bridge the gap between just understanding a video and actually writing the code myself?
    submitted by    /u/Om_JR  
 [link]   [comments]

Beginner in Django/Backend: I understand tutorials but freeze when building on my own. How do I improve?

<div class="md">Just curious. </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/MarvellousBee"> /u/MarvellousBee </a> <a href="https://www.reddit.com/r/django/comments/1s9rcwd/hardest_migration_in_production_you_ever_had_to/">[link]</a> &#32; <a href="https://www.reddit.com/r/django/comments/1s9rcwd/hardest_migration_in_production_you_ever_had_to/">[comments]</a>

Just curious.
    submitted by    /u/MarvellousBee  
 [link]   [comments]

Hardest migration in production you ever had to carry out?

<div class="md">I want to understand how I can implement something similar to google permissions system... Is there a library or another tool better suited for this? </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/beardbreed"> /u/beardbreed </a> <a href="https://www.reddit.com/r/django/comments/1s8np25/so_granular_permissions_how_to/">[link]</a> &#32; <a href="https://www.reddit.com/r/django/comments/1s8np25/so_granular_permissions_how_to/">[comments]</a>

I want to understand how I can implement something similar to google permissions system... Is there a library or another tool better suited for this? 
    submitted by    /u/beardbreed  
 [link]   [comments]

So... Granular permissions? How to?

<div class="md">I am learning Django and i think Core Schafer is a good tutor but his Django course is old its from 2018. So i am wondering if Django courses from 2017 or 2018 still relevant in 2026? </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/Leading_Property2066"> /u/Leading_Property2066 </a> <a href="https://www.reddit.com/r/django/comments/1sceitv/are_old_django_courses_still_relevant_today/">[link]</a> &#32; <a href="https://www.reddit.com/r/django/comments/1sceitv/are_old_django_courses_still_relevant_today/">[comments]</a>

I am learning Django and i think Core Schafer is a good tutor but his Django course is old its from 2018. 
 So i am wondering if Django courses from 2017 or 2018 still relevant in 2026?
    submitted by    /u/Leading_Property2066  
 [link]   [comments]

Are Old Django courses still relevant today?

<div class="md">Hey <a href="/r/django">r/django</a> — I&#39;m a self-taught career changer trying to break into my first dev role and I could really use experienced eyes on my project before I keep applying. The project: Skincare Allergy Filter — a full-stack Django 6.0 web app where users build an allergen profile and scan cosmetic ingredient lists for conflicts. 👉 <a href="https://github.com/RJChoe/Skincare-Filter-Web-Application">https://github.com/RJChoe/Skincare-Filter-Web-Application</a> My background: Not a CS grad. Before this I was a LASIK surgery tech and a GIA-certified jeweler. I&#39;ve been self-teaching Python/Django since 2024, completed Harvard&#39;s CS50 Python cert, and have been building this project seriously since September 2025 (300+ commits). Everything else is self-taught from docs, projects, and iteration. What I&#39;ve built: <ul> <li>Custom Django user model, relational DB models with constraints and validation</li> <li>pytest suite with fixtures and branch coverage</li> <li>CI/CD via GitHub Actions + Codecov with enforced coverage thresholds</li> <li>Code quality gates: ruff, mypy, bandit</li> <li>11-document technical documentation suite (architecture, security, deployment, migrations, ops)</li> <li>Gate-based development workflow I designed and managed solo</li> </ul> What I already know is rough: <ul> <li>Early commit messages are bad. I know. They&#39;ve improved significantly in the last week or two, but the history is what it is.</li> <li>Same with early PR descriptions.</li> <li>This is a learning-as-I-go project, so there&#39;s probably a lot I don&#39;t know I don&#39;t know — which is exactly why I&#39;m here.</li> </ul> What I&#39;m hoping you&#39;ll look at: <ol> <li>Is my Django code structured the way a real team would expect? (models, views, project layout)</li> <li>Does my test approach look like I understand what I&#39;m testing, or does it look like I&#39;m just chasing coverage numbers?</li> <li>Is there anything in here that would make a hiring dev immediately close the tab?</li> <li>Anything you&#39;d tell a junior dev to fix or learn next?</li> </ol> I&#39;ve sent 80+ applications and haven&#39;t gotten a single interview. I&#39;m not looking for encouragement — I want to know what&#39;s actually wrong so I can fix it. Brutal honesty appreciated. Thanks in advance. </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/NewDance7202"> /u/NewDance7202 </a> <a href="https://www.reddit.com/r/django/comments/1sap4wr/seeking_honest_code_review_django_portfolio/">[link]</a> &#32; <a href="https://www.reddit.com/r/django/comments/1sap4wr/seeking_honest_code_review_django_portfolio/">[comments]</a>

Hey r/django — I'm a self-taught career changer trying to break into my first dev role and I could really use experienced eyes on my project before I keep applying.
 The project: Skincare Allergy Filter — a full-stack Django 6.0 web app where users build an allergen profile and scan cosmetic ingredient lists for conflicts. 👉 https://github.com/RJChoe/Skincare-Filter-Web-Application
 My background: Not a CS grad. Before this I was a LASIK surgery tech and a GIA-certified jeweler. I've been self-teaching Python/Django since 2024, completed Harvard's CS50 Python cert, and have been building this project seriously since September 2025 (300+ commits). Everything else is self-taught from docs, projects, and iteration.
 What I've built:
  
Custom Django user model, relational DB models with constraints and validation
 pytest suite with fixtures and branch coverage
 CI/CD via GitHub Actions + Codecov with enforced coverage thresholds
 Code quality gates: ruff, mypy, bandit
 11-document technical documentation suite (architecture, security, deployment, migrations, ops)
 Gate-based development workflow I designed and managed solo
  
What I already know is rough:
  
Early commit messages are bad. I know. They've improved significantly in the last week or two, but the history is what it is.
 Same with early PR descriptions.
 This is a learning-as-I-go project, so there's probably a lot I don't know I don't know — which is exactly why I'm here.
  
What I'm hoping you'll look at:
  
Is my Django code structured the way a real team would expect? (models, views, project layout)
 Does my test approach look like I understand what I'm testing, or does it look like I'm just chasing coverage numbers?
 Is there anything in here that would make a hiring dev immediately close the tab?
 Anything you'd tell a junior dev to fix or learn next?
  
I've sent 80+ applications and haven't gotten a single interview. I'm not looking for encouragement — I want to know what's actually wrong so I can fix it. Brutal honesty appreciated.
 Thanks in advance.
    submitted by    /u/NewDance7202  
 [link]   [comments]

Seeking honest code review — Django portfolio project (self-taught career changer, 80+ apps, 0 interviews)

<div class="md">Hi everyone, I’m working on a backend system for a supermarket app and I’m trying to design the user roles and access models in a clean and scalable way. The system has: <ul> <li>Companies (a chain/network)</li> <li>Stores (multiple stores under a company)</li> <li>Suppliers, products, etc.</li> </ul> Users in the system can be: <ul> <li>Owner (manages the whole company)</li> <li>Manager (manages one or multiple stores)</li> <li>Operator (adds suppliers, products, etc. for a store)</li> <li>Receiver (handles goods receiving)</li> <li>Customer (regular user, not tied to stores)</li> </ul> What approach would you recommend for this kind of system? </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/iamsupalonely"> /u/iamsupalonely </a> <a href="https://www.reddit.com/r/django/comments/1s8l832/need_advice_on_model_designs/">[link]</a> &#32; <a href="https://www.reddit.com/r/django/comments/1s8l832/need_advice_on_model_designs/">[comments]</a>

Hi everyone,
 I’m working on a backend system for a supermarket app and I’m trying to design the user roles and access models in a clean and scalable way. 
 The system has:
  
Companies (a chain/network)
 Stores (multiple stores under a company)
 Suppliers, products, etc.
  
Users in the system can be:
  
Owner (manages the whole company)
 Manager (manages one or multiple stores)
 Operator (adds suppliers, products, etc. for a store)
 Receiver (handles goods receiving)
 Customer (regular user, not tied to stores)
  
What approach would you recommend for this kind of system?
    submitted by    /u/iamsupalonely  
 [link]   [comments]

Need advice on model designs

<div class="md">I have a hobby app that I wrote to manage a sports league. It&#39;s live on a website &amp; being hosted by a cloud provider. If I wanted to open this up to others outside my group, what are things I need to know on the buisness/legal side of things? For example, are there things related to Personally Identifiable Information I need to watch out for? Can I assume the cloud provider is securing their servers well enough? Do I need an LLC? Tell me what kinds of things you ran into when your app went live and was opened up to the universe. </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/nuevedientes"> /u/nuevedientes </a> <a href="https://www.reddit.com/r/django/comments/1s7rp9u/hobby_to_production_app_what_do_i_need_to_know/">[link]</a> &#32; <a href="https://www.reddit.com/r/django/comments/1s7rp9u/hobby_to_production_app_what_do_i_need_to_know/">[comments]</a>

I have a hobby app that I wrote to manage a sports league. It's live on a website & being hosted by a cloud provider. If I wanted to open this up to others outside my group, what are things I need to know on the buisness/legal side of things? For example, are there things related to Personally Identifiable Information I need to watch out for? Can I assume the cloud provider is securing their servers well enough? Do I need an LLC?
 Tell me what kinds of things you ran into when your app went live and was opened up to the universe.
    submitted by    /u/nuevedientes  
 [link]   [comments]

Hobby to Production app - What do I need to know?

<div class="md">Hey everyone! How’s it going? I just wanted to share that I’ve officially launched my first website. It’s live now and I’d love for you to check it out! I’m open to any constructive criticism or feedback you might have. Here’s the link: <a href="http://sebasssssss123123123.pythonanywhere.com/">sebasssssss123123123.pythonanywhere.com/</a> <a href="https://preview.redd.it/ur5q51edtfsg1.png?width=1919&amp;format=png&amp;auto=webp&amp;s=5c22cb18074107434eef0beb437fa1f7ad01041a">https://preview.redd.it/ur5q51edtfsg1.png?width=1919&amp;format=png&amp;auto=webp&amp;s=5c22cb18074107434eef0beb437fa1f7ad01041a</a> </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/Weak_Luck1357"> /u/Weak_Luck1357 </a> <a href="https://www.reddit.com/r/django/comments/1s8yinf/my_first_page_focused_on_lil_peep/">[link]</a> &#32; <a href="https://www.reddit.com/r/django/comments/1s8yinf/my_first_page_focused_on_lil_peep/">[comments]</a>

Hey everyone! How’s it going? I just wanted to share that I’ve officially launched my first website. It’s live now and I’d love for you to check it out! I’m open to any constructive criticism or feedback you might have. Here’s the link: sebasssssss123123123.pythonanywhere.com/
 https://preview.redd.it/ur5q51edtfsg1.png?width=1919&format=png&auto=webp&s=5c22cb18074107434eef0beb437fa1f7ad01041a
    submitted by    /u/Weak_Luck1357  
 [link]   [comments]

My first page, focused on Lil Peep

&#32; submitted by &#32; <a href="https://www.reddit.com/user/tbhaxor"> /u/tbhaxor </a> <a href="/r/selfhosted/comments/1sb7nzk/proxyforge_solving_ip_throttling/">[link]</a> &#32; <a href="https://www.reddit.com/r/django/comments/1sb7oko/proxyforge_solving_ip_throttling/">[comments]</a>

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

ProxyForge - Solving IP Throttling

<div class="md">Hi. How would i run a specific task that has to read data from database and make request to specific url in django. </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/Imaginary_Food_7102"> /u/Imaginary_Food_7102 </a> <a href="https://www.reddit.com/r/django/comments/1sd2t2h/run_task_on_backend/">[link]</a> &#32; <a href="https://www.reddit.com/r/django/comments/1sd2t2h/run_task_on_backend/">[comments]</a>

Hi. How would i run a specific task that has to read data from database and make request to specific url in django.
    submitted by    /u/Imaginary_Food_7102  
 [link]   [comments]

Run task on backend

&#32; submitted by &#32; <a href="https://www.reddit.com/user/mythical_cosmic"> /u/mythical_cosmic </a> <a href="/r/djangolearning/comments/1s8kb5b/i_built_a_realtime_debugging_dashboard_for_django/">[link]</a> &#32; <a href="https://www.reddit.com/r/django/comments/1s8kbhh/i_built_a_realtime_debugging_dashboard_for_django/">[comments]</a>

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

I built a real-time debugging dashboard for Django (like Laravel Telescope)

<div class="md">Hi, So my business stakeholders believe that changing software is as easy as changing the format in Excel. Old db sch ma is on the verge of becoming obselete. And it&#39;s not very easy to migrate old data into new schema. So, how do you generally prefer to handle these? <ol> <li>Make new tables, store all new data in it, then force user to convert old data into new one and then once everything is moved, then delete old tables? </li> <li>Write all the migration script upfront and design new schema in such a way so that it will be maximum compatible with old schema. </li> <li>Make new tables and then create api/v2/ for all the new data. And handle old in the old ways. On frontend end will make pages for the new data. And old will stay like that only. </li> </ol> </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/virtualshivam"> /u/virtualshivam </a> <a href="https://www.reddit.com/r/django/comments/1s7wbfh/updating_app_in_ever_changing_data_requirements/">[link]</a> &#32; <a href="https://www.reddit.com/r/django/comments/1s7wbfh/updating_app_in_ever_changing_data_requirements/">[comments]</a>

Hi, 
 So my business stakeholders believe that changing software is as easy as changing the format in Excel. 
 Old db sch ma is on the verge of becoming obselete. And it's not very easy to migrate old data into new schema. 
 So, how do you generally prefer to handle these?
  
Make new tables, store all new data in it, then force user to convert old data into new one and then once everything is moved, then delete old tables? 
 
Write all the migration script upfront and design new schema in such a way so that it will be maximum compatible with old schema. 
 
Make new tables and then create api/v2/ for all the new data. And handle old in the old ways. On frontend end will make pages for the new data. And old will stay like that only. 
 
    submitted by    /u/virtualshivam  
 [link]   [comments]

Updating app in ever changing data requirements.

<div class="md">Is Django 5 By Example outdated? Do you guys have any books relevant for Django 6 that I can use to learn on top of the official documentation (part 1 to 8)? </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/letsgo_iyz"> /u/letsgo_iyz </a> <a href="https://www.reddit.com/r/django/comments/1sdnria/django_5_by_example_should_i_learn_using_this/">[link]</a> &#32; <a href="https://www.reddit.com/r/django/comments/1sdnria/django_5_by_example_should_i_learn_using_this/">[comments]</a>

Is Django 5 By Example outdated? Do you guys have any books relevant for Django 6 that I can use to learn on top of the official documentation (part 1 to 8)?
    submitted by    /u/letsgo_iyz  
 [link]   [comments]

Django 5 By Example: Should I learn using this book in 2026?

<div class="md">Hi everyone, I&#39;m building an API with Django REST Framework, and I want to support multiple languages (currently English and French). I already have a <code>UserSettings</code> model linked to my user, where I store the user&#39;s preferred language (e.g. <code>&quot;en&quot;</code> or <code>&quot;fr&quot;</code>).I want to return all message in the user’s language <ul> <li>API error messages (eg. invalid credentials)</li> <li>Success messages (e.g ; &quot;Your purchase was successful&quot;)</li> <li>System messages (e.g. &quot;Profile updated&quot;)</li> <li>Notifications (e.g. push/email/in-app messages)</li> </ul> Right now, I’m considering two approaches: <ol> <li>Using Django’s built-in i18n system (<code>gettext</code> / <code>_()</code>) with a middleware that activate the language based on <code>request.user.settings.language</code>.</li> <li>Build a custom JSON-based translation system where I define message keys (e.g. <code>&quot;purchase_success&quot;</code>) and return the translated string manually depending on the user&#39;s language.</li> </ol> However, I’d prefer not to use <code>.po</code> files, as I find them harder to maintain and less flexible for my use case. my concerns <ul> <li>I want something scalable and clean.</li> <li>I don’t want to overcomplicate the backend.</li> <li>I’d like to follow best practices used in production.</li> </ul> Questions: <ul> <li>Which approach is best for production? Are there another approaches I should consider?</li> <li>Do you usually return message code (e.g. <code>&quot;PURCHASE_SUCCESS&quot;</code>) along with translated text?</li> </ul> THANKS </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/sadeckbt"> /u/sadeckbt </a> <a href="https://www.reddit.com/r/django/comments/1s90ooi/best_way_to_handle_multilingual_messages_errors/">[link]</a> &#32; <a href="https://www.reddit.com/r/django/comments/1s90ooi/best_way_to_handle_multilingual_messages_errors/">[comments]</a>

Hi everyone,
 I'm building an API with Django REST Framework, and I want to support multiple languages (currently English and French).
 I already have a UserSettings model linked to my user, where I store the user's preferred language (e.g. "en" or "fr").I want to return all message in the user’s language
  
API error messages (eg. invalid credentials)
 Success messages (e.g ; "Your purchase was successful")
 System messages (e.g. "Profile updated")
 Notifications (e.g. push/email/in-app messages)
  
Right now, I’m considering two approaches:
  
Using Django’s built-in i18n system (gettext / _()) with a middleware that activate the language based on request.user.settings.language.
 Build a custom JSON-based translation system where I define message keys (e.g. "purchase_success") and return the translated string manually depending on the user's language.
  
However, I’d prefer not to use .po files, as I find them harder to maintain and less flexible for my use case.
 my concerns
  
I want something scalable and clean.
 I don’t want to overcomplicate the backend.
 I’d like to follow best practices used in production.
  
Questions:
  
Which approach is best for production? Are there another approaches I should consider?
 Do you usually return message code (e.g. "PURCHASE_SUCCESS") along with translated text?
  
THANKS
    submitted by    /u/sadeckbt  
 [link]   [comments]

Best way to handle multilingual messages (errors, success, notifications) in Django API with user-based language?

&#32; submitted by &#32; <a href="https://www.reddit.com/user/mythical_cosmic"> /u/mythical_cosmic </a> <a href="https://www.reddit.com/gallery/1s8po6t">[link]</a> &#32; <a href="https://www.reddit.com/r/django/comments/1s8poos/this_is_screenshots_from_djangoscope_if_you_like/">[comments]</a>

This is screenshots from django-scope. If you like it please leave a Star!

&#32; submitted by &#32; <a href="https://www.reddit.com/user/Ankur_41"> /u/Ankur_41 </a> <a href="/r/PythonLearning/comments/1s8p7mh/finding_tutorial_for_django_and_flask/">[link]</a> &#32; <a href="https://www.reddit.com/r/django/comments/1s8p8br/finding_tutorial_for_django_and_flask/">[comments]</a>

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

Finding tutorial for django and flask

&#32; submitted by &#32; <a href="https://www.reddit.com/user/GHost_Exus"> /u/GHost_Exus </a> <a href="/r/SideProject/comments/1s7wf8n/i_rebuilt_my_url_shortener_minime_after_running/">[link]</a> &#32; <a href="https://www.reddit.com/r/django/comments/1s7wgqd/i_rebuilt_my_url_shortener_minime_after_running/">[comments]</a>

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

I rebuilt my URL shortener (M-ini.me) after running it free for years ... would love your feedback

<div class="md">hey guys, I use gunicorn with gthread. Since flask is sync. I wanna know how many concurrent requests do I get over time, and if it every exceeds worker*threads, in my case 10*10=100. and if I need to add more threads. How can I monitor it? I use flask with gunicorn, docker, nginx in front. Also have netadata enabled. </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/Consistent_Tutor_597"> /u/Consistent_Tutor_597 </a> <a href="https://www.reddit.com/r/flask/comments/1sasuox/how_can_i_monitor_how_many_requests_am_i/">[link]</a> &#32; <a href="https://www.reddit.com/r/flask/comments/1sasuox/how_can_i_monitor_how_many_requests_am_i/">[comments]</a>

hey guys, I use gunicorn with gthread. Since flask is sync. I wanna know how many concurrent requests do I get over time, and if it every exceeds worker*threads, in my case 10*10=100. and if I need to add more threads. How can I monitor it? 
 I use flask with gunicorn, docker, nginx in front. Also have netadata enabled. 
    submitted by    /u/Consistent_Tutor_597  
 [link]   [comments]

How can I monitor how many requests am I processing rn and how many are waiting?

<div class="md">OS: Windows 11 python: 3.9.13 I have two machines (main, laptop) running Windows 11. The main machine I have recently re-formatted. On this machine I&#39;ve cloned my github repo, set up the environment, installed the requirements (from requirements.txt file in repo) and set up the projects configuration files. The application itself works fine with <code>flask run</code>. The database can be read from and written to. On the main machine if I do <code>flask db migrate -m &quot;my new table&quot;</code> I get the error message <code>flask db = Error: No such command &#39;db&#39;.</code> . Running flask --help outputs the folllowing: ```Usage: flask [OPTIONS] COMMAND [ARGS]... A general utility script for Flask applications. Provides commands from Flask, extensions, and the application. Loads the application defined in the FLASK_APP environment variable, or from a wsgi.py file. Setting the FLASK_ENV environment variable to &#39;development&#39; will enable debug mode. <pre><code>&gt; set FLASK_APP=hello.py &gt; set FLASK_ENV=development &gt; flask run </code></pre> Options: --version Show the flask version --help Show this message and exit. Commands: add-admin Add a admin user. add-groups Add / update the default groups. routes Show the routes for the app. run Run a development server. shell Run a shell in the app context. sync-odoo-lines Update the odoo line items for all open projects. upcoming-projects Email notification of status of upcoming projects. ``` We can see here that the command db isn&#39;t added. The additional commands I have added are visible. <hr/> On my laptop (Windows 11, not reformatted) I can follow the same steps as above and the db command is available as expected. <hr/> A simplification of my structure is as follows: <code> /application/ /application_bp_1/ /application_bp_2/ /application_.../ __init__.py .env ... </code> <code>__init__.py</code> contains the application configuration ``` app = Flask(name) db = SQLAlchemy(app) migrate = Migrate(app, db) ``` So far I&#39;ve <ul> <li>remade the env serveral times</li> <li> uninstall python, cleared all cache files, reinstalled</li> </ul> I have tried looking for similar errors it seems to be all about initialising the db correctly which I&#39;m sure I have done. Remember, this same project, cloned from the repo, same dependencies, same python version, works fine on the laptop. Anybody have any idea what I&#39;ve missed? Any pointers on how to debug this? </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/evereux"> /u/evereux </a> <a href="https://www.reddit.com/r/flask/comments/1s8pbr0/flask_db_error_no_such_command_db/">[link]</a> &#32; <a href="https://www.reddit.com/r/flask/comments/1s8pbr0/flask_db_error_no_such_command_db/">[comments]</a>

OS: Windows 11 python: 3.9.13
 I have two machines (main, laptop) running Windows 11. The main machine I have recently re-formatted. On this machine I've cloned my github repo, set up the environment, installed the requirements (from requirements.txt file in repo) and set up the projects configuration files.
 The application itself works fine with flask run. The database can be read from and written to.
 On the main machine if I do flask db migrate -m "my new table" I get the error message flask db = Error: No such command 'db'. . 
 Running flask --help outputs the folllowing: ```Usage: flask [OPTIONS] COMMAND [ARGS]...
 A general utility script for Flask applications.
 Provides commands from Flask, extensions, and the application. Loads the application defined in the FLASK_APP environment variable, or from a wsgi.py file. Setting the FLASK_ENV environment variable to 'development' will enable debug mode.
 > set FLASK_APP=hello.py > set FLASK_ENV=development > flask run 
 Options: --version Show the flask version --help Show this message and exit.
 Commands: add-admin Add a admin user. add-groups Add / update the default groups. routes Show the routes for the app. run Run a development server. shell Run a shell in the app context. sync-odoo-lines Update the odoo line items for all open projects. upcoming-projects Email notification of status of upcoming projects. ```
 We can see here that the command db isn't added. 
 The additional commands I have added are visible. 
  
On my laptop (Windows 11, not reformatted) I can follow the same steps as above and the db command is available as expected.
  
A simplification of my structure is as follows:
  /application/ /application_bp_1/ /application_bp_2/ /application_.../ __init__.py .env ... 
 __init__.py contains the application configuration
 ``` app = Flask(name) db = SQLAlchemy(app) migrate = Migrate(app, db)
 ```
 So far I've
  
remade the env serveral times
  uninstall python, cleared all cache files, reinstalled
  
I have tried looking for similar errors it seems to be all about initialising the db correctly which I'm sure I have done. Remember, this same project, cloned from the repo, same dependencies, same python version, works fine on the laptop.
 Anybody have any idea what I've missed?
 Any pointers on how to debug this?
    submitted by    /u/evereux  
 [link]   [comments]

flask db = Error: No such command 'db'

<table> <tr><td> <a href="https://www.reddit.com/r/flask/comments/1s9s82o/simple_bodyweight_workout_webapp/"> <img src="https://preview.redd.it/07fzxd69cmsg1.png?width=140&amp;height=77&amp;auto=webp&amp;s=356f8b9a1801abc5a926a433ffdefba8a40a1ef0" alt="Simple bodyweight workout webapp" title="Simple bodyweight workout webapp" /> </a> </td><td> <div class="md">i have been trying to build a workout app for a while now. This is the 4th time i rewrite this project cli ( just a generator basicly ) -&gt; kivy app-&gt; kivymd app-&gt; flask app with bootstrap5 last year-&gt; this time: flask with tailwind. stack: - sqlite - tailwind ( first project with tailwind, still getting the hang of it) - database: sqlite - flask - vanilla js, chart.js for charts, driver js for the onboarding. - hosted on pythonanywhere <h2>About the app</h2> Floor is primarily bodyweight workout app, its name comes from the fact that you could start the beginner routine right now, with no equipments, and even the ones that require one its not much, ( chair, pull up bar, dip station, slider disc ) it embeds youtube videos to show you how the workout is done. logs reps, keeps a rolling some for exercises and records time spent on sets. you can share the workout with others, they can yoink your routine ( no that is the real term i am funny like that ) there is a guest login if you do not want to register. but i would really like if you would check it out and would provide some feedback. <a href="https://floorwarior.pythonanywhere.com">https://floorwarior.pythonanywhere.com</a> </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/wannasleeponyourhams"> /u/wannasleeponyourhams </a> <a href="https://www.reddit.com/gallery/1s9s82o">[link]</a> &#32; <a href="https://www.reddit.com/r/flask/comments/1s9s82o/simple_bodyweight_workout_webapp/">[comments]</a> </td></tr></table>

i have been trying to build a workout app for a while now. This is the 4th time i rewrite this project cli ( just a generator basicly ) -> kivy app-> kivymd app-> flask app with bootstrap5 last year-> this time: flask with tailwind.
 stack: - sqlite - tailwind ( first project with tailwind, still getting the hang of it) - database: sqlite - flask - vanilla js, chart.js for charts, driver js for the onboarding. - hosted on pythonanywhere
 About the app
 Floor is primarily bodyweight workout app, its name comes from the fact that you could start the beginner routine right now, with no equipments, and even the ones that require one its not much, ( chair, pull up bar, dip station, slider disc ) it embeds youtube videos to show you how the workout is done. logs reps, keeps a rolling some for exercises and records time spent on sets. you can share the workout with others, they can yoink your routine ( no that is the real term i am funny like that )
 there is a guest login if you do not want to register.
 but i would really like if you would check it out and would provide some feedback.
 https://floorwarior.pythonanywhere.com
    submitted by    /u/wannasleeponyourhams  
 [link]   [comments]

Simple bodyweight workout webapp

<div class="md">Hey everyone, I’ve been working a lot with Django recently, and one thing that always bothered me was the lack of a modern, real-time debugging experience. Most existing tools are either: - not real-time - hard to use in larger projects - or introduce noticeable performance overhead So I decided to build something myself: django-scope. It’s a real-time debugging and observability dashboard for Django, inspired by Laravel Telescope, but redesigned with performance and developer experience in mind. Key things it does: - Tracks requests, queries, exceptions, logs, cache, Redis, and more - Streams everything in real-time using WebSockets - Detects N+1 query issues automatically - Uses request-scoped buffering with bulk writes to reduce overhead - Provides a clean dashboard (Vue-based, dark/light mode) The main goal wasn’t just features, but making sure it’s actually usable in real projects without slowing things down. I focused a lot on minimizing overhead and avoiding the typical “debug tools kill performance” problem. I’ve been testing it in my own projects and it’s been really helpful for understanding what’s happening inside the app in real time. I’d really appreciate feedback from other Django developers — especially on: - performance considerations - missing features - general usability GitHub: <a href="https://github.com/MythicalCosmic/django-scope">https://github.com/MythicalCosmic/django-scope</a> Its also on Pypi, check it out: pip install django-scope <a href="https://preview.redd.it/2hjz0uy8llsg1.png?width=1280&amp;format=png&amp;auto=webp&amp;s=c6c9b4844570116d888b088b4229a0e8e57adb8f">https://preview.redd.it/2hjz0uy8llsg1.png?width=1280&amp;format=png&amp;auto=webp&amp;s=c6c9b4844570116d888b088b4229a0e8e57adb8f</a> <a href="https://preview.redd.it/1f7lo1p9llsg1.png?width=1280&amp;format=png&amp;auto=webp&amp;s=0a26a578e6c2ccaca2cdd68b8dcd0ad8ff33de5c">https://preview.redd.it/1f7lo1p9llsg1.png?width=1280&amp;format=png&amp;auto=webp&amp;s=0a26a578e6c2ccaca2cdd68b8dcd0ad8ff33de5c</a> <a href="https://preview.redd.it/mlfqxf8allsg1.png?width=1280&amp;format=png&amp;auto=webp&amp;s=e4b92d0bf9dab06520da0166acf0f74319e33421">https://preview.redd.it/mlfqxf8allsg1.png?width=1280&amp;format=png&amp;auto=webp&amp;s=e4b92d0bf9dab06520da0166acf0f74319e33421</a> <a href="https://preview.redd.it/yavoxs0bllsg1.png?width=1280&amp;format=png&amp;auto=webp&amp;s=046f8bb3f367868e1fc9d88d5bf8378c0767a743">https://preview.redd.it/yavoxs0bllsg1.png?width=1280&amp;format=png&amp;auto=webp&amp;s=046f8bb3f367868e1fc9d88d5bf8378c0767a743</a> <a href="https://preview.redd.it/lfys8opbllsg1.png?width=1280&amp;format=png&amp;auto=webp&amp;s=7bbb783c906c9aa630762329996963c9b971acc3">https://preview.redd.it/lfys8opbllsg1.png?width=1280&amp;format=png&amp;auto=webp&amp;s=7bbb783c906c9aa630762329996963c9b971acc3</a> <a href="https://preview.redd.it/6im85elcllsg1.png?width=1280&amp;format=png&amp;auto=webp&amp;s=9c146d21172e40d11b411d675a1682427cb49a11">https://preview.redd.it/6im85elcllsg1.png?width=1280&amp;format=png&amp;auto=webp&amp;s=9c146d21172e40d11b411d675a1682427cb49a11</a> <a href="https://preview.redd.it/1gejzfgdllsg1.png?width=1280&amp;format=png&amp;auto=webp&amp;s=423a7d9e813877aaf32e4d3e375c62394af73fbd">https://preview.redd.it/1gejzfgdllsg1.png?width=1280&amp;format=png&amp;auto=webp&amp;s=423a7d9e813877aaf32e4d3e375c62394af73fbd</a> <a href="https://preview.redd.it/or3qav6ellsg1.png?width=1280&amp;format=png&amp;auto=webp&amp;s=cc9e9d59d56a45931176bce643d1d2294c966ef6">https://preview.redd.it/or3qav6ellsg1.png?width=1280&amp;format=png&amp;auto=webp&amp;s=cc9e9d59d56a45931176bce643d1d2294c966ef6</a> <a href="https://preview.redd.it/64uh6drellsg1.png?width=1280&amp;format=png&amp;auto=webp&amp;s=4330d503ae46e8b78fbb82486f1439d25fa8245a">https://preview.redd.it/64uh6drellsg1.png?width=1280&amp;format=png&amp;auto=webp&amp;s=4330d503ae46e8b78fbb82486f1439d25fa8245a</a> <a href="https://preview.redd.it/67m91opfllsg1.png?width=1280&amp;format=png&amp;auto=webp&amp;s=9fffb6a24a586b3d03f29e3b6c1120c7942cee87">https://preview.redd.it/67m91opfllsg1.png?width=1280&amp;format=png&amp;auto=webp&amp;s=9fffb6a24a586b3d03f29e3b6c1120c7942cee87</a> <a href="https://preview.redd.it/dqr8j3kgllsg1.png?width=1280&amp;format=png&amp;auto=webp&amp;s=4bea6343825e6e4e44917219cbc4038c611dde01">https://preview.redd.it/dqr8j3kgllsg1.png?width=1280&amp;format=png&amp;auto=webp&amp;s=4bea6343825e6e4e44917219cbc4038c611dde01</a> </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/mythical_cosmic"> /u/mythical_cosmic </a> <a href="https://www.reddit.com/r/djangolearning/comments/1s8kb5b/i_built_a_realtime_debugging_dashboard_for_django/">[link]</a> &#32; <a href="https://www.reddit.com/r/djangolearning/comments/1s8kb5b/i_built_a_realtime_debugging_dashboard_for_django/">[comments]</a>

Hey everyone,
 I’ve been working a lot with Django recently, and one thing that always bothered me was the lack of a modern, real-time debugging experience.
 Most existing tools are either:
 - not real-time
 - hard to use in larger projects
 - or introduce noticeable performance overhead
 So I decided to build something myself: django-scope.
 It’s a real-time debugging and observability dashboard for Django, inspired by Laravel Telescope, but redesigned with performance and developer experience in mind.
 Key things it does:
 - Tracks requests, queries, exceptions, logs, cache, Redis, and more
 - Streams everything in real-time using WebSockets
 - Detects N+1 query issues automatically
 - Uses request-scoped buffering with bulk writes to reduce overhead
 - Provides a clean dashboard (Vue-based, dark/light mode)
 The main goal wasn’t just features, but making sure it’s actually usable in real projects without slowing things down. I focused a lot on minimizing overhead and avoiding the typical “debug tools kill performance” problem.
 I’ve been testing it in my own projects and it’s been really helpful for understanding what’s happening inside the app in real time.
 I’d really appreciate feedback from other Django developers — especially on:
 - performance considerations
 - missing features
 - general usability
 GitHub: https://github.com/MythicalCosmic/django-scope
 Its also on Pypi, check it out: pip install django-scope
 https://preview.redd.it/2hjz0uy8llsg1.png?width=1280&format=png&auto=webp&s=c6c9b4844570116d888b088b4229a0e8e57adb8f
 https://preview.redd.it/1f7lo1p9llsg1.png?width=1280&format=png&auto=webp&s=0a26a578e6c2ccaca2cdd68b8dcd0ad8ff33de5c
 https://preview.redd.it/mlfqxf8allsg1.png?width=1280&format=png&auto=webp&s=e4b92d0bf9dab06520da0166acf0f74319e33421
 https://preview.redd.it/yavoxs0bllsg1.png?width=1280&format=png&auto=webp&s=046f8bb3f367868e1fc9d88d5bf8378c0767a743
 https://preview.redd.it/lfys8opbllsg1.png?width=1280&format=png&auto=webp&s=7bbb783c906c9aa630762329996963c9b971acc3
 https://preview.redd.it/6im85elcllsg1.png?width=1280&format=png&auto=webp&s=9c146d21172e40d11b411d675a1682427cb49a11
 https://preview.redd.it/1gejzfgdllsg1.png?width=1280&format=png&auto=webp&s=423a7d9e813877aaf32e4d3e375c62394af73fbd
 https://preview.redd.it/or3qav6ellsg1.png?width=1280&format=png&auto=webp&s=cc9e9d59d56a45931176bce643d1d2294c966ef6
 https://preview.redd.it/64uh6drellsg1.png?width=1280&format=png&auto=webp&s=4330d503ae46e8b78fbb82486f1439d25fa8245a
 https://preview.redd.it/67m91opfllsg1.png?width=1280&format=png&auto=webp&s=9fffb6a24a586b3d03f29e3b6c1120c7942cee87
 https://preview.redd.it/dqr8j3kgllsg1.png?width=1280&format=png&auto=webp&s=4bea6343825e6e4e44917219cbc4038c611dde01
    submitted by    /u/mythical_cosmic  
 [link]   [comments]

<div class="md">Hey everyone, I’m currently preparing for backend roles (internships/junior), mainly targeting startups, my tech stack is python - django, and I wanted some honest feedback on a project I’ve been working on and planning to take to a production-ready level. The project is an e-commerce backend built using Django + Django REST Framework, where I’ve tried to go beyond basic CRUD and focus on real-world backend concerns like performance, scalability, and clean API design. Here’s the overall scope of the system: Core API &amp; Design: - Designed relational models (products, categories, users, orders, cart) - Built REST APIs using DRF ViewSets and tested using postman - Custom serializer design (avoiding overuse of &quot;depth&quot;) - Clean and consistent API response structure Data &amp; Logic Handling: - Derived fields (e.g., availability computed from stock instead of storing redundant data) - Separation of concerns (keeping logic out of views where possible) Performance &amp; Optimization: - Solved N+1 query problem using &quot;select_related&quot; (touched these kind of small edge cases) - implemented caching using redis Query Capabilities: - Search functionality (SearchFilter) - Filtering (category, price range, etc.) - Pagination with metadata (count, next, previous) System Features: - JWT authentication - Cart and order management - Basic payment flow using stripe Deployment &amp; Practical Use: - Deployed on cloud (AWS) - Focus on making APIs usable in real-world scenarios My goal is to focus on more indepth and complex projects and try to land one internship or any junior role ASAP. I had a few questions: <ol> <li>Would this level of backend project be considered strong enough to get shortlisted for internship or junior backend roles at startups?</li> <li>What gaps do you usually see in candidates even after building projects like this?</li> <li>How important is deployment and real-world usability compared to just having good code on GitHub?</li> <li>Is focusing heavily on backend/system design (instead of deep DSA) a reasonable strategy for startups?</li> </ol> Would really appreciate honest feedback — especially from people working in startups or hiring for backend roles. Thanks! </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/Afraid-Army1966"> /u/Afraid-Army1966 </a> <a href="https://www.reddit.com/r/djangolearning/comments/1saalop/would_this_level_of_backend_project_be_enough_to/">[link]</a> &#32; <a href="https://www.reddit.com/r/djangolearning/comments/1saalop/would_this_level_of_backend_project_be_enough_to/">[comments]</a>

Hey everyone,
 I’m currently preparing for backend roles (internships/junior), mainly targeting startups, my tech stack is python - django, and I wanted some honest feedback on a project I’ve been working on and planning to take to a production-ready level.
 The project is an e-commerce backend built using Django + Django REST Framework, where I’ve tried to go beyond basic CRUD and focus on real-world backend concerns like performance, scalability, and clean API design.
 Here’s the overall scope of the system:
 Core API & Design:
 - Designed relational models (products, categories, users, orders, cart)
 - Built REST APIs using DRF ViewSets and tested using postman
 - Custom serializer design (avoiding overuse of "depth")
 - Clean and consistent API response structure
 Data & Logic Handling:
 - Derived fields (e.g., availability computed from stock instead of storing redundant data)
 - Separation of concerns (keeping logic out of views where possible)
 Performance & Optimization:
 - Solved N+1 query problem using "select_related" (touched these kind of small edge cases)
 - implemented caching using redis
 Query Capabilities:
 - Search functionality (SearchFilter)
 - Filtering (category, price range, etc.)
 - Pagination with metadata (count, next, previous)
 System Features:
 - JWT authentication
 - Cart and order management
 - Basic payment flow using stripe
 Deployment & Practical Use:
 - Deployed on cloud (AWS)
 - Focus on making APIs usable in real-world scenarios
 My goal is to focus on more indepth and complex projects and try to land one internship or any junior role ASAP.
 I had a few questions:
  
Would this level of backend project be considered strong enough to get shortlisted for internship or junior backend roles at startups?
 
What gaps do you usually see in candidates even after building projects like this?
 
How important is deployment and real-world usability compared to just having good code on GitHub?
 
Is focusing heavily on backend/system design (instead of deep DSA) a reasonable strategy for startups?
 
 Would really appreciate honest feedback — especially from people working in startups or hiring for backend roles.
 Thanks!
    submitted by    /u/Afraid-Army1966  
 [link]   [comments]

Would this level of backend project be enough to get shortlisted for a startup role?

<div class="md">Hi everyone, I’m preparing for a role that involves understanding VBA-based legacy systems and modernizing them into Python (likely using Django). I’m trying to understand the best way to approach this in practice, especially since the role also involves things like authentication and REST APIs. Specifically: How do you read and break down VBA code effectively? How do you decide what to refactor vs rewrite? How do you design the new system (e.g., when to expose logic via APIs)? How do you handle authentication when moving from a legacy system to a modern backend? How do you test that the new Python version behaves the same as the old system? Any real-world tips, patterns, or examples would be really helpful. Thanks! </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/Flosy22"> /u/Flosy22 </a> <a href="https://www.reddit.com/r/djangolearning/comments/1s824wy/how_do_you_approach_migrating_vba_logic_to_python/">[link]</a> &#32; <a href="https://www.reddit.com/r/djangolearning/comments/1s824wy/how_do_you_approach_migrating_vba_logic_to_python/">[comments]</a>

Hi everyone,
 I’m preparing for a role that involves understanding VBA-based legacy systems and modernizing them into Python (likely using Django).
 I’m trying to understand the best way to approach this in practice, especially since the role also involves things like authentication and REST APIs.
 Specifically:
 How do you read and break down VBA code effectively?
 How do you decide what to refactor vs rewrite?
 How do you design the new system (e.g., when to expose logic via APIs)?
 How do you handle authentication when moving from a legacy system to a modern backend?
 How do you test that the new Python version behaves the same as the old system?
 Any real-world tips, patterns, or examples would be really helpful.
 Thanks!
    submitted by    /u/Flosy22  
 [link]   [comments]

How do you approach migrating VBA logic to Python (with APIs & auth)?

<div class="md">Selfteaching backend engineering with python,django...I do not have any cs books or anything. just AI agents and youtube help me to understand the basics and the principles ..I never enjoyed coding even during my college days or more accurately, I never gave it enough focus ..but now I want to give it fair attempt .who knows what future holds. maybe only strong engineer will remain or maybe there will be more job due to AI. But I just give myself a chance to learn, grow, to master a skill .Even if it does not immediately translate into value, the process will still matter. Every skill developed and every effort made contributes to the future in some form....so even in the middle of anxiety,doubt and pressure I will continue learning. Not because it is easy but because it is necessary . .if I can try others can too </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/S7jstnameit"> /u/S7jstnameit </a> <a href="/r/django/comments/1sahi0g/learning_python_django/">[link]</a> &#32; <a href="https://www.reddit.com/r/djangolearning/comments/1sahlyk/learning_backend_engineering_with_python/">[comments]</a>

Selfteaching backend engineering with python,django...I do not have any cs books or anything. just AI agents and youtube help me to understand the basics and the principles ..I never enjoyed coding even during my college days or more accurately, I never gave it enough focus ..but now I want to give it fair attempt .who knows what future holds. maybe only strong engineer will remain or maybe there will be more job due to AI. But I just give myself a chance to learn, grow, to master a skill .Even if it does not immediately translate into value, the process will still matter. Every skill developed and every effort made contributes to the future in some form....so even in the middle of anxiety,doubt and pressure I will continue learning. Not because it is easy but because it is necessary . .if I can try others can too
    submitted by    /u/S7jstnameit  
 [link]   [comments]

Learning Backend engineering with python django,What more should add to that guys?

<div class="md">I’ve been building with FastAPI for a while now and I’m curious how people are really handling background work beyond simple demos. The docs show <code>BackgroundTasks</code>, but that feels pretty limited once things get even slightly complex. Some situations I keep running into: <ul> <li>sending emails, notifications, webhooks</li> <li>retrying failed tasks</li> <li>long running async jobs</li> <li>tasks that depend on other tasks</li> <li>needing visibility into what’s running or failing</li> </ul> Right now it feels like there are a few options: <ul> <li>stick with <code>BackgroundTasks</code></li> <li>use something like Celery or RQ</li> <li>or just push everything into a message broker</li> </ul> But none of these feel very “FastAPI-native” or simple. So I’m wondering: <ul> <li>What are you using in production?</li> <li>Are you staying fully async or mixing in workers?</li> <li>How are you handling retries and failures?</li> <li>Do you have any visibility into tasks or is it just logs and hope?</li> </ul> Would be interesting to hear what actually works in real systems, not just tutorials. </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/Educational-Hope960"> /u/Educational-Hope960 </a> <a href="https://www.reddit.com/r/FastAPI/comments/1sbnurr/how_are_you_actually_managing_backgroundasync/">[link]</a> &#32; <a href="https://www.reddit.com/r/FastAPI/comments/1sbnurr/how_are_you_actually_managing_backgroundasync/">[comments]</a>

I’ve been building with FastAPI for a while now and I’m curious how people are really handling background work beyond simple demos.
 The docs show BackgroundTasks, but that feels pretty limited once things get even slightly complex.
 Some situations I keep running into:
  
sending emails, notifications, webhooks
 retrying failed tasks
 long running async jobs
 tasks that depend on other tasks
 needing visibility into what’s running or failing
  
Right now it feels like there are a few options:
  
stick with BackgroundTasks
 use something like Celery or RQ
 or just push everything into a message broker
  
But none of these feel very “FastAPI-native” or simple.
 So I’m wondering:
  
What are you using in production?
 Are you staying fully async or mixing in workers?
 How are you handling retries and failures?
 Do you have any visibility into tasks or is it just logs and hope?
  
Would be interesting to hear what actually works in real systems, not just tutorials.
    submitted by    /u/Educational-Hope960  
 [link]   [comments]

How are you actually managing background/async tasks in FastAPI in production?

<div class="md">I&#39;m learning FastAPI and trying to add a PATCH endpoint. Asked Claude about it and it told me to create a second model called `BookUpdate` where every field is Optional, separate from my main `Book` model where everything is required. Is this really how you guys do it in practice? Feels like a lot of boilerplate just for one endpoint. What&#39;s the proper way to handle partial updates in FastAPI? </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/NiceSand6327"> /u/NiceSand6327 </a> <a href="https://www.reddit.com/r/FastAPI/comments/1sclp2e/trying_to_implement_patch_in_fastapi_and_claude/">[link]</a> &#32; <a href="https://www.reddit.com/r/FastAPI/comments/1sclp2e/trying_to_implement_patch_in_fastapi_and_claude/">[comments]</a>

I'm learning FastAPI and trying to add a PATCH endpoint. Asked Claude about it and it told me to create a second model called `BookUpdate` where every field is Optional, separate from my main `Book` model where everything is required.
 Is this really how you guys do it in practice? Feels like a lot of boilerplate just for one endpoint. What's the proper way to handle partial updates in FastAPI?
    submitted by    /u/NiceSand6327  
 [link]   [comments]

Trying to implement PATCH in FastAPI and Claude told me to use two separate Pydantic models — is this actually the way?

<div class="md">FastAPI doesn&#39;t ship with any real observability. I&#39;ve rebuilt some version of this on every FastAPI repo I&#39;ve worked on. Eventually I got tired of repeating myself and made it a proper library. It started as my own use, but I have been expanding it ever since. <pre><code>registry = HealthRegistry(app) registry.add(PostgreSQLProbe(url=&quot;postgresql://...&quot;)) registry.add(RedisProbe(url=&quot;redis://...&quot;), critical=False) </code></pre> That gives you <code>/health/live</code>, <code>/health/ready</code>, <code>/health/status</code>, <code>/health/metrics</code> (Prometheus), and a live dashboard at <code>/health/dashboard</code>. A few things that make it different: <ul> <li>Probes run concurrently — so if Redis takes 5 seconds, your Postgres check isn&#39;t waiting on it</li> <li>Many probes are passive observers (<code>@probe.watch</code>) — they instrument your existing functions instead of making synthetic test requests</li> <li>Three health states: <code>healthy</code>, <code>degraded</code>, <code>unhealthy</code> — degraded keeps <code>/ready</code> at 200 but surfaces in the dashboard and Prometheus</li> <li>Built-in Slack, Teams, and PagerDuty alerts on state changes</li> <li>Circuit breaker, probe history, SSE streaming, Kubernetes-ready</li> </ul> GitHub: <a href="https://github.com/rgreen1207/fastapi-watch">https://github.com/rgreen1207/fastapi-watch</a> <code>pip install fastapi-watch</code> </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/Delta1262"> /u/Delta1262 </a> <a href="https://www.reddit.com/r/FastAPI/comments/1s86eyu/fastapiwatch_health_checks_metrics_and_a_live/">[link]</a> &#32; <a href="https://www.reddit.com/r/FastAPI/comments/1s86eyu/fastapiwatch_health_checks_metrics_and_a_live/">[comments]</a>

FastAPI doesn't ship with any real observability. I've rebuilt some version of this on every FastAPI repo I've worked on. Eventually I got tired of repeating myself and made it a proper library. It started as my own use, but I have been expanding it ever since.
 registry = HealthRegistry(app) registry.add(PostgreSQLProbe(url="postgresql://...")) registry.add(RedisProbe(url="redis://..."), critical=False) 
 That gives you /health/live, /health/ready, /health/status, /health/metrics (Prometheus), and a live dashboard at /health/dashboard.
 A few things that make it different:
  
Probes run concurrently — so if Redis takes 5 seconds, your Postgres check isn't waiting on it
 Many probes are passive observers (@probe.watch) — they instrument your existing functions instead of making synthetic test requests
 Three health states: healthy, degraded, unhealthy — degraded keeps /ready at 200 but surfaces in the dashboard and Prometheus
 Built-in Slack, Teams, and PagerDuty alerts on state changes
 Circuit breaker, probe history, SSE streaming, Kubernetes-ready
  
GitHub: https://github.com/rgreen1207/fastapi-watch 
 pip install fastapi-watch
    submitted by    /u/Delta1262  
 [link]   [comments]

fastapi-watch — health checks, metrics, and a live dashboard for FastAPI in one registry call

<div class="md">Hi <a href="/r/fastapi">/r/fastapi</a>, I maintain <a href="https://github.com/maldoinc/wireup">Wireup</a>, a type-driven DI library for Python, and I recently improved the FastAPI integration. The part I think is most useful for FastAPI is <code>WireupTask</code>, a small wrapper that makes background task functions DI-aware. It lets you inject dependencies into FastAPI background task callbacks. Each task gets its own scope, separate from the request and other tasks, so it gets fresh scoped services like DB sessions and transactions, while still sharing app-wide singletons where appropriate. I wanted this for background task code that still needs DI and cleanup, without manually rebuilding services or passing extra objects down from the request. You can also use the same services outside HTTP, like in CLIs and workers. Example: <pre><code>from fastapi import BackgroundTasks, FastAPI import wireup import wireup.integration.fastapi from wireup import Injected, injectable from wireup.integration.fastapi import WireupTask # Create a wireup container and FastAPI app as usual. container = wireup.create_async_container(injectables=[GreeterService]) # Define an injectable @injectable class GreeterService: def greet(self, name: str) -&gt; str: return f&quot;Hello, {name}!&quot; # Background task functions can now have injected dependencies. # `Injected[T]` is like `Depends`, but resolved by Wireup&#39;s container. def write_greeting(name: str, greeter: Injected[GreeterService]) -&gt; None: print(greeter.greet(name)) app = FastAPI() # Regular route handler. @app.post(&quot;/enqueue&quot;) async def enqueue( name: str, tasks: BackgroundTasks, wireup_task: Injected[WireupTask], ): tasks.add_task(wireup_task(write_greeting), name) return {&quot;ok&quot;: True} # Set up the integration after creating the app and container. wireup.integration.fastapi.setup(container, app) </code></pre> Wireup also supports injection in route handlers and elsewhere in the request path, testing, and request/websocket context in services. You can adopt it incrementally alongside <code>Depends</code>. You can also define app-wide (<code>singleton</code>), per-request (<code>scoped</code>), and always-fresh (<code>transient</code>) services in one place, with startup validation for missing deps, cycles, lifetime mismatches, and config errors. If you&#39;re already using <code>Depends</code>, I also wrote a migration guide for moving over one service at a time. I also included benchmarks vs FastAPI <code>Depends</code>, with the methodology and benchmark code in the docs. Background tasks: <a href="https://maldoinc.github.io/wireup/latest/integrations/fastapi/background_tasks/">https://maldoinc.github.io/wireup/latest/integrations/fastapi/background_tasks/</a> FastAPI integration docs: <a href="https://maldoinc.github.io/wireup/latest/integrations/fastapi/">https://maldoinc.github.io/wireup/latest/integrations/fastapi/</a> Migration guide from <code>Depends</code>: <a href="https://maldoinc.github.io/wireup/latest/migrate_to_wireup/fastapi_depends/">https://maldoinc.github.io/wireup/latest/migrate_to_wireup/fastapi_depends/</a> Benchmarks: <a href="https://maldoinc.github.io/wireup/latest/benchmarks/">https://maldoinc.github.io/wireup/latest/benchmarks/</a> Repo: <a href="https://github.com/maldoinc/wireup">https://github.com/maldoinc/wireup</a> Curious to know how you&#39;re solving this currently in background tasks. </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/ForeignSource0"> /u/ForeignSource0 </a> <a href="https://www.reddit.com/r/FastAPI/comments/1s8qz83/wireup_for_fastapi_now_supports_di_in_background/">[link]</a> &#32; <a href="https://www.reddit.com/r/FastAPI/comments/1s8qz83/wireup_for_fastapi_now_supports_di_in_background/">[comments]</a>

Hi /r/fastapi,
 I maintain Wireup, a type-driven DI library for Python, and I recently improved the FastAPI integration. The part I think is most useful for FastAPI is WireupTask, a small wrapper that makes background task functions DI-aware.
 It lets you inject dependencies into FastAPI background task callbacks. Each task gets its own scope, separate from the request and other tasks, so it gets fresh scoped services like DB sessions and transactions, while still sharing app-wide singletons where appropriate.
 I wanted this for background task code that still needs DI and cleanup, without manually rebuilding services or passing extra objects down from the request. You can also use the same services outside HTTP, like in CLIs and workers.
 Example:
 from fastapi import BackgroundTasks, FastAPI import wireup import wireup.integration.fastapi from wireup import Injected, injectable from wireup.integration.fastapi import WireupTask # Create a wireup container and FastAPI app as usual. container = wireup.create_async_container(injectables=[GreeterService]) # Define an injectable @injectable class GreeterService: def greet(self, name: str) -> str: return f"Hello, {name}!" # Background task functions can now have injected dependencies. # `Injected[T]` is like `Depends`, but resolved by Wireup's container. def write_greeting(name: str, greeter: Injected[GreeterService]) -> None: print(greeter.greet(name)) app = FastAPI() # Regular route handler. @app.post("/enqueue") async def enqueue( name: str, tasks: BackgroundTasks, wireup_task: Injected[WireupTask], ): tasks.add_task(wireup_task(write_greeting), name) return {"ok": True} # Set up the integration after creating the app and container. wireup.integration.fastapi.setup(container, app) 
 Wireup also supports injection in route handlers and elsewhere in the request path, testing, and request/websocket context in services. You can adopt it incrementally alongside Depends.
 You can also define app-wide (singleton), per-request (scoped), and always-fresh (transient) services in one place, with startup validation for missing deps, cycles, lifetime mismatches, and config errors.
 If you're already using Depends, I also wrote a migration guide for moving over one service at a time.
 I also included benchmarks vs FastAPI Depends, with the methodology and benchmark code in the docs.
 Background tasks: https://maldoinc.github.io/wireup/latest/integrations/fastapi/background_tasks/
 FastAPI integration docs: https://maldoinc.github.io/wireup/latest/integrations/fastapi/
 Migration guide from Depends: https://maldoinc.github.io/wireup/latest/migrate_to_wireup/fastapi_depends/
 Benchmarks: https://maldoinc.github.io/wireup/latest/benchmarks/
 Repo: https://github.com/maldoinc/wireup
 Curious to know how you're solving this currently in background tasks.
    submitted by    /u/ForeignSource0  
 [link]   [comments]

Wireup for FastAPI now supports DI in background tasks

<div class="md">Learning FastAPI and not sure what the right approach is. Should I just use HTTPException directly in my endpoints or should I be creating custom exception classes with global handlers? What do you do in production? </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/NiceSand6327"> /u/NiceSand6327 </a> <a href="https://www.reddit.com/r/FastAPI/comments/1scyzzu/whats_the_best_practice_for_exception_handling_in/">[link]</a> &#32; <a href="https://www.reddit.com/r/FastAPI/comments/1scyzzu/whats_the_best_practice_for_exception_handling_in/">[comments]</a>

Learning FastAPI and not sure what the right approach is. Should I just use HTTPException directly in my endpoints or should I be creating custom exception classes with global handlers?
 What do you do in production?
    submitted by    /u/NiceSand6327  
 [link]   [comments]

What's the best practice for exception handling in FastAPI?

<div class="md">Hi everyone, I’ve been working on Dynantic, a Python ORM for DynamoDB. The project started because I wanted to use Pydantic v2 models directly as database models in my FastAPI/Lambda stack, without the need to map them to proprietary ORM types (like PynamoDB attributes) or raw Boto3 dictionaries. What My Project Does Dynantic is a synchronous-first ORM that maps Pydantic v2 models to DynamoDB tables. It handles all the complex Boto3 serialization and deserialization behind the scenes, allowing you to work with native Python types while ensuring data validation at the database level. It includes a DSL for queries, support for GSIs, and built-in handling for batch operations and transactions. Core approach: Single Table Design &amp; Polymorphism One of the main focuses of the library is how it handles multiple entities within a single table. Instead of manual parsing, it uses a discriminator pattern to automatically instantiate the correct subclass when querying the base table: Python <pre><code>from dynantic import DynamoModel, Key, Discriminator class Asset(DynamoModel): asset_id: str = Key() type: str = Discriminator() # Auto-tracks the subclass type class Meta: table_name = &quot;infrastructure&quot; @Asset.register(&quot;SERVER&quot;) class Server(Asset): cpu_cores: int memory_gb: int @Asset.register(&quot;DATABASE&quot;) class Database(Asset): engine: str # When you scan or query, you get back the actual subclasses for asset in Asset.scan(): if isinstance(asset, Server): print(f&quot;Server {asset.asset_id}: {asset.cpu_cores} cores&quot;) </code></pre> Key Technical Points: <ul> <li>Type Safety: Native support for UUIDs, Enums, Datetimes, and Sets using Pydantic’s validation engine.</li> <li>Atomic Updates: Support for ADD, SET, and REMOVE operations without fetching the item first (saving RCU).</li> <li>Production Tooling: Support for ACID Transactions, Batch operations (with auto-chunking/retries), and TTL.</li> <li>Utilities: Built-in support for Auto-UUID generation (<code>Key(auto=True)</code>) and automatic response pagination (cursor-based) for stateless APIs.</li> <li>Lambda Optimized: The library is intentionally synchronous-first to minimize cold starts and avoid the overhead of aioboto3 in serverless environments.</li> </ul> Target Audience Dynantic is designed for developers building serverless backends with AWS Lambda and FastAPI who are looking for a &quot;SQLModel-like&quot; developer experience. It’s for anyone who wants to maintain a single source of truth for their data models across their API and database layers. Comparison <ul> <li>vs PynamoDB: While PynamoDB is mature, it requires using its own attribute types. Dynantic uses pure Pydantic v2, allowing for better integration with the modern Python ecosystem.</li> <li>vs Boto3: Boto3 is extremely verbose and requires manual management of expression attributes. Dynantic provides a high-level DSL that makes complex queries much more readable and type-safe.</li> </ul> AI Integration: You can also find a Claude Code Skill in the repository that helped me better using the library with llm. Since new libraries aren&#39;t in the training data of current LLMs, this skill provides coding agents with the context of the DSL and best practices, making it easier to generate valid models and queries. The project is currently in Beta (0.3.1). I’d love to get some honest feedback on the API design or any rough edges you might find! GitHub:<a href="https://github.com/Simi24/dynantic">https://github.com/Simi24/dynantic</a> PyPI: <code>pip install dynantic</code> </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/Simi_auto3"> /u/Simi_auto3 </a> <a href="https://www.reddit.com/r/FastAPI/comments/1sak33o/dynantic_a_pydanticv2_orm_for_dynamodb_because_i/">[link]</a> &#32; <a href="https://www.reddit.com/r/FastAPI/comments/1sak33o/dynantic_a_pydanticv2_orm_for_dynamodb_because_i/">[comments]</a>

Hi everyone,
 I’ve been working on Dynantic, a Python ORM for DynamoDB. The project started because I wanted to use Pydantic v2 models directly as database models in my FastAPI/Lambda stack, without the need to map them to proprietary ORM types (like PynamoDB attributes) or raw Boto3 dictionaries.
 What My Project Does Dynantic is a synchronous-first ORM that maps Pydantic v2 models to DynamoDB tables. It handles all the complex Boto3 serialization and deserialization behind the scenes, allowing you to work with native Python types while ensuring data validation at the database level. It includes a DSL for queries, support for GSIs, and built-in handling for batch operations and transactions.
 Core approach: Single Table Design & Polymorphism One of the main focuses of the library is how it handles multiple entities within a single table. Instead of manual parsing, it uses a discriminator pattern to automatically instantiate the correct subclass when querying the base table:
 Python
 from dynantic import DynamoModel, Key, Discriminator class Asset(DynamoModel): asset_id: str = Key() type: str = Discriminator() # Auto-tracks the subclass type class Meta: table_name = "infrastructure" @Asset.register("SERVER") class Server(Asset): cpu_cores: int memory_gb: int @Asset.register("DATABASE") class Database(Asset): engine: str # When you scan or query, you get back the actual subclasses for asset in Asset.scan(): if isinstance(asset, Server): print(f"Server {asset.asset_id}: {asset.cpu_cores} cores") 
 Key Technical Points:
  
Type Safety: Native support for UUIDs, Enums, Datetimes, and Sets using Pydantic’s validation engine.
 Atomic Updates: Support for ADD, SET, and REMOVE operations without fetching the item first (saving RCU).
 Production Tooling: Support for ACID Transactions, Batch operations (with auto-chunking/retries), and TTL.
 Utilities: Built-in support for Auto-UUID generation (Key(auto=True)) and automatic response pagination (cursor-based) for stateless APIs.
 Lambda Optimized: The library is intentionally synchronous-first to minimize cold starts and avoid the overhead of aioboto3 in serverless environments.
  
Target Audience Dynantic is designed for developers building serverless backends with AWS Lambda and FastAPI who are looking for a "SQLModel-like" developer experience. It’s for anyone who wants to maintain a single source of truth for their data models across their API and database layers.
 Comparison
  
vs PynamoDB: While PynamoDB is mature, it requires using its own attribute types. Dynantic uses pure Pydantic v2, allowing for better integration with the modern Python ecosystem.
 vs Boto3: Boto3 is extremely verbose and requires manual management of expression attributes. Dynantic provides a high-level DSL that makes complex queries much more readable and type-safe.
  
AI Integration: You can also find a Claude Code Skill in the repository that helped me better using the library with llm. Since new libraries aren't in the training data of current LLMs, this skill provides coding agents with the context of the DSL and best practices, making it easier to generate valid models and queries.
 The project is currently in Beta (0.3.1). I’d love to get some honest feedback on the API design or any rough edges you might find!
 GitHub:https://github.com/Simi24/dynantic
 PyPI: pip install dynantic
    submitted by    /u/Simi_auto3  
 [link]   [comments]

Dynantic - A Pydantic-v2 ORM for DynamoDB (because I was tired of duplicating models)

<table> <tr><td> <a href="https://www.reddit.com/r/FastAPI/comments/1s9nz1t/rate_limiting_in_fastapi_what_the_popular/"> <img src="https://preview.redd.it/chi5evsnmlsg1.png?width=140&amp;height=76&amp;auto=webp&amp;s=9a739012ce439aafba26b5980f8e408d25a1c3be" alt="Rate Limiting in FastAPI: What the Popular Libraries Miss" title="Rate Limiting in FastAPI: What the Popular Libraries Miss" /> </a> </td><td> <div class="md">Rate limiting is how you stop a single client from hammering your API. You cap the number of requests per time window and return a 429 when they go over. Simple idea, but the implementation details matter in production. Here is how the two most popular FastAPI rate limiting libraries work: slowapi <pre><code>from slowapi import Limiter from slowapi.util import get_remote_address from fastapi import Request limiter = Limiter(key_func=get_remote_address) @app.get(&quot;/search&quot;) @limiter.limit(&quot;10/minute&quot;) async def search(request: Request): return {&quot;results&quot;: []} </code></pre> fastapi-limiter <pre><code>from fastapi_limiter import FastAPILimiter from fastapi_limiter.depends import RateLimiter import redis.asyncio as redis from fastapi import Depends @app.on_event(&quot;startup&quot;) async def startup(): r = await redis.from_url(&quot;redis://localhost&quot;) await FastAPILimiter.init(r) @app.get(&quot;/search&quot;, dependencies=[Depends(RateLimiter(times=10, seconds=60))]) async def search(): return {&quot;results&quot;: []} </code></pre> Both get the job done for basic IP-based limiting. But here is where they fall short: No runtime mutation. Every limit is locked to the code. If you want to update the limit on an existing route or apply a rate limit to a route that was not decorated at deploy time, you have to change code and redeploy. No management tooling. There is no dashboard or CLI to view current policies, add limits to unprotected routes, update existing limits, or see which requests are being blocked. Everything lives in code and the only way to inspect the state of your rate limits is to read the source. This is what the same thing looks like in <a href="https://attakay78.github.io/waygate/tutorial/rate-limiting/">waygate</a>: <pre><code>from waygate.fastapi import rate_limit # IP-based (default) @router.get(&quot;/search&quot;) @rate_limit(&quot;10/minute&quot;) async def search(): return {&quot;results&quot;: []} # Per user, with tiered limits for different plans @router.get(&quot;/reports&quot;) @rate_limit( {&quot;free&quot;: &quot;10/minute&quot;, &quot;pro&quot;: &quot;100/minute&quot;, &quot;enterprise&quot;: &quot;unlimited&quot;}, key=&quot;user&quot;, ) async def reports(request: Request): return {&quot;reports&quot;: []} # Exempt internal IPs @router.get(&quot;/metrics&quot;) @rate_limit(&quot;20/minute&quot;, exempt_ips=[&quot;10.0.0.0/8&quot;, &quot;127.0.0.1&quot;]) async def metrics(): return {&quot;metrics&quot;: {}} </code></pre> Change a limit at runtime without touching code: <pre><code>waygate rl set GET:/search 50/minute waygate rl reset GET:/search waygate rl hits </code></pre> The admin dashboard shows all registered policies, lets you add limits to unprotected routes, and logs every blocked request. For multi-service architectures, waygate lets you set a rate limit policy that applies to every route of a specific service without touching individual handlers, and manages all policies across services from a single dashboard. waygate also covers feature flags with OpenFeature support, maintenance mode, scheduled windows, percentage rollouts, webhooks, and a full audit log, all in one library with no redeploy required. <code>pip install &quot;waygate[rate-limit]&quot;</code> Docs: <a href="https://attakay78.github.io/waygate">https://attakay78.github.io/waygate</a> <a href="https://preview.redd.it/chi5evsnmlsg1.png?width=2994&amp;format=png&amp;auto=webp&amp;s=2c6e3921d51fd69ed19dbe5908747a9c490ca026">https://preview.redd.it/chi5evsnmlsg1.png?width=2994&amp;format=png&amp;auto=webp&amp;s=2c6e3921d51fd69ed19dbe5908747a9c490ca026</a> </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/Educational-Hope960"> /u/Educational-Hope960 </a> <a href="https://www.reddit.com/r/FastAPI/comments/1s9nz1t/rate_limiting_in_fastapi_what_the_popular/">[link]</a> &#32; <a href="https://www.reddit.com/r/FastAPI/comments/1s9nz1t/rate_limiting_in_fastapi_what_the_popular/">[comments]</a> </td></tr></table>

Rate limiting is how you stop a single client from hammering your API. You cap the number of requests per time window and return a 429 when they go over. Simple idea, but the implementation details matter in production.
 Here is how the two most popular FastAPI rate limiting libraries work:
 slowapi
 from slowapi import Limiter from slowapi.util import get_remote_address from fastapi import Request limiter = Limiter(key_func=get_remote_address) @app.get("/search") @limiter.limit("10/minute") async def search(request: Request): return {"results": []} 
 fastapi-limiter
 from fastapi_limiter import FastAPILimiter from fastapi_limiter.depends import RateLimiter import redis.asyncio as redis from fastapi import Depends @app.on_event("startup") async def startup(): r = await redis.from_url("redis://localhost") await FastAPILimiter.init(r) @app.get("/search", dependencies=[Depends(RateLimiter(times=10, seconds=60))]) async def search(): return {"results": []} 
 Both get the job done for basic IP-based limiting. But here is where they fall short:
 No runtime mutation. Every limit is locked to the code. If you want to update the limit on an existing route or apply a rate limit to a route that was not decorated at deploy time, you have to change code and redeploy.
 No management tooling. There is no dashboard or CLI to view current policies, add limits to unprotected routes, update existing limits, or see which requests are being blocked. Everything lives in code and the only way to inspect the state of your rate limits is to read the source.
 This is what the same thing looks like in waygate:
 from waygate.fastapi import rate_limit # IP-based (default) @router.get("/search") @rate_limit("10/minute") async def search(): return {"results": []} # Per user, with tiered limits for different plans @router.get("/reports") @rate_limit( {"free": "10/minute", "pro": "100/minute", "enterprise": "unlimited"}, key="user", ) async def reports(request: Request): return {"reports": []} # Exempt internal IPs @router.get("/metrics") @rate_limit("20/minute", exempt_ips=["10.0.0.0/8", "127.0.0.1"]) async def metrics(): return {"metrics": {}} 
 Change a limit at runtime without touching code:
 waygate rl set GET:/search 50/minute waygate rl reset GET:/search waygate rl hits 
 The admin dashboard shows all registered policies, lets you add limits to unprotected routes, and logs every blocked request.
 For multi-service architectures, waygate lets you set a rate limit policy that applies to every route of a specific service without touching individual handlers, and manages all policies across services from a single dashboard.
 waygate also covers feature flags with OpenFeature support, maintenance mode, scheduled windows, percentage rollouts, webhooks, and a full audit log, all in one library with no redeploy required.
 pip install "waygate[rate-limit]"
 Docs: https://attakay78.github.io/waygate
 https://preview.redd.it/chi5evsnmlsg1.png?width=2994&format=png&auto=webp&s=2c6e3921d51fd69ed19dbe5908747a9c490ca026
    submitted by    /u/Educational-Hope960  
 [link]   [comments]

Rate Limiting in FastAPI: What the Popular Libraries Miss

<div class="md">Most agentic AI repos are either: • toy demos • or heavy frameworks I wanted something in between. A production-style starter template you can actually ship from. After building multiple agent workflows, I kept rewriting the same things: • workflow orchestration • persistence • retries • project structure • agent separation So I turned it into a reusable template. What it includes: • FastAPI based execution layer • LangGraph workflow orchestration • Production-style project structure • Resilient Postgres checkpoint saver (auto reconnect handling) • Agent workflow patterns ready to extend • Clean separation between agents / workflows / infra • Designed to be hackable instead of framework-locked Main goal: Something between a demo repo and an over-engineered framework. Just a solid starting point you can actually ship from. Repo: <a href="https://github.com/samirpatil2000/agentic-template">https://github.com/samirpatil2000/agentic-template</a> Would love feedback on: • Architecture improvements • Missing production features • Observability patterns • Memory strategies • Agent reliability patterns Curious how others here are structuring production agent systems. </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/Moist_Tonight_3997"> /u/Moist_Tonight_3997 </a> <a href="https://www.reddit.com/r/FastAPI/comments/1s7ynzw/built_a_productionready_fastapi_langgraph/">[link]</a> &#32; <a href="https://www.reddit.com/r/FastAPI/comments/1s7ynzw/built_a_productionready_fastapi_langgraph/">[comments]</a>

Most agentic AI repos are either:
 • toy demos
 • or heavy frameworks
 I wanted something in between. A production-style starter template you can actually ship from.
 After building multiple agent workflows, I kept rewriting the same things:
 • workflow orchestration
 • persistence
 • retries
 • project structure
 • agent separation
 So I turned it into a reusable template.
 What it includes:
 • FastAPI based execution layer 
 • LangGraph workflow orchestration 
 • Production-style project structure 
 • Resilient Postgres checkpoint saver (auto reconnect handling) 
 • Agent workflow patterns ready to extend 
 • Clean separation between agents / workflows / infra 
 • Designed to be hackable instead of framework-locked 
 Main goal:
 Something between a demo repo and an over-engineered framework. Just a solid starting point you can actually ship from.
 Repo:
 https://github.com/samirpatil2000/agentic-template
 Would love feedback on:
 • Architecture improvements 
 • Missing production features 
 • Observability patterns 
 • Memory strategies 
 • Agent reliability patterns 
 Curious how others here are structuring production agent systems.
    submitted by    /u/Moist_Tonight_3997  
 [link]   [comments]

Built a production-ready FastAPI + LangGraph template for agent workflows (open source)

<table> <tr><td> <a href="https://www.reddit.com/r/FastAPI/comments/1sc5xav/how_do_you_know_if_your_fastapi_backgroundtasks/"> <img src="https://preview.redd.it/1mqh2uvzi5tg1.png?width=140&amp;height=75&amp;auto=webp&amp;s=bdffae45c47e8365af00e1776f78369dff5e55b6" alt="How do you know if your FastAPI BackgroundTasks actually ran?" title="How do you know if your FastAPI BackgroundTasks actually ran?" /> </a> </td><td> <div class="md">I asked this question here earlier about managing tasks in FastAPI and most people pointed me to Celery. Which makes sense. But for smaller applications that don’t need high throughput, distributed workers, or long-running jobs, Celery feels like overkill. Spinning up Redis or RabbitMQ just to send emails or process small background work didn’t feel right for me. So I stuck with FastAPI’s <code>BackgroundTasks</code>. The problem is… once you do: <pre><code>background_tasks.add_task(...) </code></pre> you lose visibility. <ul> <li>No task ID</li> <li>No status</li> <li>No retries</li> <li>No idea if it failed unless you check logs</li> </ul> It works, but it feels like a black box. So instead of switching to a full queue system, I built something around it: <code>fastapi-bg-taskmanager</code>. The idea is simple: keep using <code>BackgroundTasks</code>, but add the missing management layer. What it adds: <ul> <li><code>@task_manager.task(retries=3, delay=1.0, backoff=2.0)</code> to configure retry behavior per task</li> <li>Every task gets a <code>task_id</code> and moves through <code>PENDING -&gt; RUNNING -&gt; SUCCESS / FAILED</code></li> <li>Live dashboard at <code>/tasks/dashboard</code> using SSE (no polling)</li> <li>SQLite persistence so task history survives restarts</li> <li>Pending tasks that didn’t finish before shutdown get requeued on startup</li> </ul> Example: <pre><code>task_manager = TaskManager(snapshot_db=&quot;tasks.db&quot;) TaskAdmin(app, task_manager, auto_install=True) @task_manager.task(retries=3, delay=1.0, backoff=2.0) def send_email(address: str) -&gt; None: ... @app.post(&quot;/signup&quot;) def signup(email: str, background_tasks: BackgroundTasks): task_id = background_tasks.add_task(send_email, address=email) return {&quot;task_id&quot;: task_id} </code></pre> <a href="https://preview.redd.it/1mqh2uvzi5tg1.png?width=3012&amp;format=png&amp;auto=webp&amp;s=2bd3d41ea5def4bcf2bb819685254ed1c27afe4c">Sample Task Management Dashboard</a> Still early, but it’s been useful for my own app. I’m trying to validate if this is actually worth building out further: <ul> <li>Would you prefer this kind of lightweight layer for smaller projects?</li> <li>What would make this a no-brainer for you to adopt?</li> <li>What&#39;s missing and you think will be fine to add?</li> </ul> Would really appreciate honest feedback. </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/Educational-Hope960"> /u/Educational-Hope960 </a> <a href="https://www.reddit.com/r/FastAPI/comments/1sc5xav/how_do_you_know_if_your_fastapi_backgroundtasks/">[link]</a> &#32; <a href="https://www.reddit.com/r/FastAPI/comments/1sc5xav/how_do_you_know_if_your_fastapi_backgroundtasks/">[comments]</a> </td></tr></table>

I asked this question here earlier about managing tasks in FastAPI and most people pointed me to Celery.
 Which makes sense.
 But for smaller applications that don’t need high throughput, distributed workers, or long-running jobs, Celery feels like overkill. Spinning up Redis or RabbitMQ just to send emails or process small background work didn’t feel right for me.
 So I stuck with FastAPI’s BackgroundTasks.
 The problem is… once you do:
 background_tasks.add_task(...) 
 you lose visibility.
  
No task ID
 No status
 No retries
 No idea if it failed unless you check logs
  
It works, but it feels like a black box.
 So instead of switching to a full queue system, I built something around it: fastapi-bg-taskmanager.
 The idea is simple: keep using BackgroundTasks, but add the missing management layer.
 What it adds:
  
@task_manager.task(retries=3, delay=1.0, backoff=2.0) to configure retry behavior per task
 Every task gets a task_id and moves through PENDING -> RUNNING -> SUCCESS / FAILED
 Live dashboard at /tasks/dashboard using SSE (no polling)
 SQLite persistence so task history survives restarts
 Pending tasks that didn’t finish before shutdown get requeued on startup
  
Example:
 task_manager = TaskManager(snapshot_db="tasks.db") TaskAdmin(app, task_manager, auto_install=True) @task_manager.task(retries=3, delay=1.0, backoff=2.0) def send_email(address: str) -> None: ... @app.post("/signup") def signup(email: str, background_tasks: BackgroundTasks): task_id = background_tasks.add_task(send_email, address=email) return {"task_id": task_id} 
 Sample Task Management Dashboard
 Still early, but it’s been useful for my own app.
 I’m trying to validate if this is actually worth building out further:
  
Would you prefer this kind of lightweight layer for smaller projects?
 What would make this a no-brainer for you to adopt?
 What's missing and you think will be fine to add?
  
Would really appreciate honest feedback.
    submitted by    /u/Educational-Hope960  
 [link]   [comments]

How do you know if your FastAPI BackgroundTasks actually ran?

<table> <tr><td> <a href="https://www.reddit.com/r/FastAPI/comments/1sdazyz/question_on_api_design/"> <img src="https://external-preview.redd.it/ar-L0hm3RCb2R4m5JlnB-R8RrljQRMPSoT8VgE27_7Q.png?width=140&amp;height=121&amp;auto=webp&amp;s=0db40d26be5b484ef6ed334090d53eba4f1901b8" alt="Question on API Design" title="Question on API Design" /> </a> </td><td> <div class="md">Hi, I&#39;ve been working on building an API for a very simple project-management system just to teach myself the basics and I&#39;ve stumbled upon a confusing use-case. The world of the system looks like this <a href="https://preview.redd.it/rtq8kt0nzetg1.png?width=1704&amp;format=png&amp;auto=webp&amp;s=2017cfa9e4f6fec65831b98617b5c43639854194">https://preview.redd.it/rtq8kt0nzetg1.png?width=1704&amp;format=png&amp;auto=webp&amp;s=2017cfa9e4f6fec65831b98617b5c43639854194</a> <a href="https://preview.redd.it/question-on-api-design-v0-2xwr8cfzzdtg1.png?width=1704&amp;format=png&amp;auto=webp&amp;s=1cf4dfee55a2cbeae576f5a34b0b20f7fb1dbb83"></a> I&#39;ve got the following roles: <pre><code>1. ORG_MEMBER: Organization members are allowed to - Creation of projects 2. ORG_ADMIN: Organization admins are allowed to - CRUD of organization members - the C in CRUD here refers to &quot;inviting&quot; members... atop all access rights of organization members 3. PROJ_MEMBER: Project members are allowed to - CRUD of tasks - Comments on all tasks within project - View project history 4. PROJ_MANAGER: Project managers are allowed to - RUD of projects - CRUD of buckets - CRUD of project members (add organization members into project, remove project users from project) </code></pre> Since the &quot;creation of a project&quot; rests at the scope of an organization, and not at the scope of a project (because it doesn&#39;t exist yet), I&#39;m having a hard time figuring out which dependency to inject into the route. <pre><code>def get_current_user(token: HTTPAuthorizationCredentials = Depends(token_auth_scheme)): try: user_response = supabase.auth.get_user(token.credentials) supabase_user = user_response.user if not supabase_user: raise HTTPException( status_code=401, detail=&quot;Invalid token or user not found.&quot; ) auth_id = supabase_user.id user_data = supabase.table(&quot;users&quot;).select(&quot;*&quot;).eq(&quot;user_id&quot;, str(auth_id)).execute() if not user_data.data: raise HTTPException( status_code=404, detail=&quot;User not found in database.&quot; ) user_data = user_data.data[0] return User( user_id=user_data[&quot;user_id&quot;], user_name=user_data[&quot;user_name&quot;], email_id=user_data[&quot;email_id&quot;], full_name=user_data[&quot;full_name&quot;] ) except Exception as e: raise HTTPException( status_code=401, detail=f&quot;Invalid token or user not found: {e}&quot; ) def get_org_user(org_id: str, user: User = Depends(get_current_user)): res = supabase.table(&quot;org_users&quot;).select(&quot;*&quot;).eq(&quot;user_id&quot;, user.user_id).eq(&quot;org_id&quot;, org_id).single().execute() if not res.data: raise HTTPException( status_code=403, detail=&quot;User is not a member of this organization.&quot; ) return OrgUser( user_id=res.data[&quot;user_id&quot;], org_id=res.data[&quot;org_id&quot;], role=res.data[&quot;role&quot;] ) def get_proj_user(proj_id: str, user: User = Depends(get_current_user)): res = supabase.table(&quot;proj_users&quot;).select(&quot;*&quot;).eq(&quot;user_id&quot;, user.user_id).eq(&quot;proj_id&quot;, proj_id).single().execute() if not res.data: raise HTTPException( status_code=403, detail=&quot;User is not a member of this project.&quot; ) return ProjUser( user_id=res.data[&quot;user_id&quot;], proj_id=res.data[&quot;proj_id&quot;], role=res.data[&quot;role&quot;] ) </code></pre> Above are what my dependencies are... this is essentially my dependency factory <pre><code># rbac dependency factory class EntityPermissionChecker: def __init__(self, required_permission: str, entity_type: str): self.required_permission = required_permission self.entity_type = entity_type self.db = supabase def __call__(self, request: Request, user: User = Depends(get_current_user)): if self.entity_type == &quot;org&quot;: view_name = &quot;org_permissions_view&quot; id_param = &quot;org_id&quot; elif self.entity_type == &quot;project&quot;: view_name = &quot;proj_permissions_view&quot; id_param = &quot;proj_id&quot; else: raise HTTPException( status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, detail=&quot;Invalid entity type for permission checking.&quot; ) entity_id = request.path_params.get(id_param) if not entity_id: raise HTTPException( status_code=status.HTTP_400_BAD_REQUEST, detail=f&quot;Missing {id_param} in request path.&quot; ) response = self.db.table(view_name).select(&quot;permission_name&quot;).eq(&quot;user_id&quot;, user.user_id).eq(id_param, entity_id).eq(&quot;permission_name&quot;, self.required_permission).execute() if not response.data: raise HTTPException( status_code=status.HTTP_403_FORBIDDEN, detail=&quot;you do not have permission to perform this action.&quot; ) return True </code></pre> i&#39;ve got 3 ways to write the POST/ route for creating a project... <ol> <li>Either i inject the normal User dependency @/router.post( &quot;/&quot;, response_model=APIResponse[ProjectResponse], status_code=status.HTTP_201_CREATED ) def create_project( org_id: str, project_data: ProjectCreate, user: User= Depends(get_current_user) ): data = ProjectService().create_project(project_data, user.user_id) return { &quot;message&quot;: &quot;Project created successfully&quot;, &quot;data&quot;: data }</li> </ol> so the route would be POST: projects/ with a body : <pre><code>class ProjectCreate(BaseModel): proj_name: str org_id: str </code></pre> and here i let the ProjectService handle the verification of the user&#39;s permissions <ol> <li>or i inject an OrgUser instead @/router.post( &quot;/org/{org_id}&quot;, response_model=APIResponse[ProjectResponse], status_code=status.HTTP_201_CREATED, dependencies=[Depends(EntityPermissionChecker(&quot;create:organization&quot;, &quot;org&quot;))] ) def create_project( project_data: ProjectCreate, user: OrgUser = Depends(get_org_user) # has to depend on an OrgUser, because creating a project is at the scope of an org (proj hasn&#39;t been created yet!) ): data = ProjectService().create_project(project_data, user.user_id) return { &quot;message&quot;: &quot;Project created successfully&quot;, &quot;data&quot;: data }</li> </ol> and have the route look like POST:/projects/org/{org_id} which looks nasty, and have the body be <pre><code>class ProjectCreate(BaseModel): proj_name: str </code></pre> <ol> <li>or i just create the route within the organizations_router.py (where i have the CRUD routes for the organizations...) @/router.post( &quot;/{org_id}/project&quot;, response_model=APIResponse[ProjectResponse], status_code=status.HTTP_201_CREATED, dependencies=[Depends(EntityPermissionChecker(&quot;create:project&quot;, &quot;org&quot;))] ) def create_project_in_org( org_id: str, project_data: ProjectCreate, user: OrgUser = Depends(get_org_user) ): data = ProjectService().create_project(project_data, user.user_id) return { &quot;message&quot;: &quot;Project created successfully within organization.&quot;, &quot;data&quot;: data }</li> </ol> and the route looks like POST:/organizations/{org_id}/projects .... but then all project related routes don&#39;t fall under the projects_router.py and the POST/ one alone falls under organizations_router.py I personally think the 3rd one is best, but is there a better alternative? </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/OrganizationOnly8016"> /u/OrganizationOnly8016 </a> <a href="https://www.reddit.com/r/FastAPI/comments/1sdazyz/question_on_api_design/">[link]</a> &#32; <a href="https://www.reddit.com/r/FastAPI/comments/1sdazyz/question_on_api_design/">[comments]</a> </td></tr></table>

Hi, I've been working on building an API for a very simple project-management system just to teach myself the basics and I've stumbled upon a confusing use-case.
 The world of the system looks like this
 https://preview.redd.it/rtq8kt0nzetg1.png?width=1704&format=png&auto=webp&s=2017cfa9e4f6fec65831b98617b5c43639854194
 
 I've got the following roles:
 1. ORG_MEMBER: Organization members are allowed to - Creation of projects 2. ORG_ADMIN: Organization admins are allowed to - CRUD of organization members - the C in CRUD here refers to "inviting" members... atop all access rights of organization members 3. PROJ_MEMBER: Project members are allowed to - CRUD of tasks - Comments on all tasks within project - View project history 4. PROJ_MANAGER: Project managers are allowed to - RUD of projects - CRUD of buckets - CRUD of project members (add organization members into project, remove project users from project) 
 Since the "creation of a project" rests at the scope of an organization, and not at the scope of a project (because it doesn't exist yet), I'm having a hard time figuring out which dependency to inject into the route.
 def get_current_user(token: HTTPAuthorizationCredentials = Depends(token_auth_scheme)): try: user_response = supabase.auth.get_user(token.credentials) supabase_user = user_response.user if not supabase_user: raise HTTPException( status_code=401, detail="Invalid token or user not found." ) auth_id = supabase_user.id user_data = supabase.table("users").select("*").eq("user_id", str(auth_id)).execute() if not user_data.data: raise HTTPException( status_code=404, detail="User not found in database." ) user_data = user_data.data[0] return User( user_id=user_data["user_id"], user_name=user_data["user_name"], email_id=user_data["email_id"], full_name=user_data["full_name"] ) except Exception as e: raise HTTPException( status_code=401, detail=f"Invalid token or user not found: {e}" ) def get_org_user(org_id: str, user: User = Depends(get_current_user)): res = supabase.table("org_users").select("*").eq("user_id", user.user_id).eq("org_id", org_id).single().execute() if not res.data: raise HTTPException( status_code=403, detail="User is not a member of this organization." ) return OrgUser( user_id=res.data["user_id"], org_id=res.data["org_id"], role=res.data["role"] ) def get_proj_user(proj_id: str, user: User = Depends(get_current_user)): res = supabase.table("proj_users").select("*").eq("user_id", user.user_id).eq("proj_id", proj_id).single().execute() if not res.data: raise HTTPException( status_code=403, detail="User is not a member of this project." ) return ProjUser( user_id=res.data["user_id"], proj_id=res.data["proj_id"], role=res.data["role"] ) 
 Above are what my dependencies are...
 this is essentially my dependency factory
 # rbac dependency factory class EntityPermissionChecker: def __init__(self, required_permission: str, entity_type: str): self.required_permission = required_permission self.entity_type = entity_type self.db = supabase def __call__(self, request: Request, user: User = Depends(get_current_user)): if self.entity_type == "org": view_name = "org_permissions_view" id_param = "org_id" elif self.entity_type == "project": view_name = "proj_permissions_view" id_param = "proj_id" else: raise HTTPException( status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, detail="Invalid entity type for permission checking." ) entity_id = request.path_params.get(id_param) if not entity_id: raise HTTPException( status_code=status.HTTP_400_BAD_REQUEST, detail=f"Missing {id_param} in request path." ) response = self.db.table(view_name).select("permission_name").eq("user_id", user.user_id).eq(id_param, entity_id).eq("permission_name", self.required_permission).execute() if not response.data: raise HTTPException( status_code=status.HTTP_403_FORBIDDEN, detail="you do not have permission to perform this action." ) return True 
 i've got 3 ways to write the POST/ route for creating a project...
  
Either i inject the normal User dependency @/router.post( "/", response_model=APIResponse[ProjectResponse], status_code=status.HTTP_201_CREATED ) def create_project( org_id: str, project_data: ProjectCreate, user: User= Depends(get_current_user) ): data = ProjectService().create_project(project_data, user.user_id) return { "message": "Project created successfully", "data": data }
  
so the route would be POST: projects/ with a body :
 class ProjectCreate(BaseModel): proj_name: str org_id: str 
 and here i let the ProjectService handle the verification of the user's permissions
  
or i inject an OrgUser instead
 @/router.post( "/org/{org_id}", response_model=APIResponse[ProjectResponse], status_code=status.HTTP_201_CREATED, dependencies=[Depends(EntityPermissionChecker("create:organization", "org"))] ) def create_project( project_data: ProjectCreate, user: OrgUser = Depends(get_org_user) # has to depend on an OrgUser, because creating a project is at the scope of an org (proj hasn't been created yet!) ): data = ProjectService().create_project(project_data, user.user_id) return { "message": "Project created successfully", "data": data }
 
 and have the route look like POST:/projects/org/{org_id} which looks nasty, and have the body be
 class ProjectCreate(BaseModel): proj_name: str 
  
or i just create the route within the organizations_router.py (where i have the CRUD routes for the organizations...)
 @/router.post( "/{org_id}/project", response_model=APIResponse[ProjectResponse], status_code=status.HTTP_201_CREATED, dependencies=[Depends(EntityPermissionChecker("create:project", "org"))] ) def create_project_in_org( org_id: str, project_data: ProjectCreate, user: OrgUser = Depends(get_org_user) ): data = ProjectService().create_project(project_data, user.user_id) return { "message": "Project created successfully within organization.", "data": data }
 
 and the route looks like POST:/organizations/{org_id}/projects ....
 but then all project related routes don't fall under the projects_router.py and the POST/ one alone falls under organizations_router.py
 I personally think the 3rd one is best, but is there a better alternative?
    submitted by    /u/OrganizationOnly8016  
 [link]   [comments]

Question on API Design

<div class="md">Hey all, I&#39;ve been working on a pet project of mine using Vue 3 and FastAPI, and I was working on a small lib to quickly help me seed my DB. I was aiming for something similar to what I had from my PHP time when I was working with Laravel. I finally decided to extract it from my pet project into a library and publish it. I&#39;d appreciate your feedback and would like to share it with the community in case this is someone else&#39;s pain point. <a href="https://github.com/arthurvasconcelos/seedling">https://github.com/arthurvasconcelos/seedling</a> <a href="https://pypi.org/project/sqlalchemy-seedling/">https://pypi.org/project/sqlalchemy-seedling/</a> </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/jookeringa"> /u/jookeringa </a> <a href="https://www.reddit.com/r/FastAPI/comments/1s87hqu/seeder_lib_for_sqlalchemy/">[link]</a> &#32; <a href="https://www.reddit.com/r/FastAPI/comments/1s87hqu/seeder_lib_for_sqlalchemy/">[comments]</a>

Hey all, I've been working on a pet project of mine using Vue 3 and FastAPI, and I was working on a small lib to quickly help me seed my DB. I was aiming for something similar to what I had from my PHP time when I was working with Laravel.
 I finally decided to extract it from my pet project into a library and publish it. I'd appreciate your feedback and would like to share it with the community in case this is someone else's pain point.
 https://github.com/arthurvasconcelos/seedling
 https://pypi.org/project/sqlalchemy-seedling/
    submitted by    /u/jookeringa  
 [link]   [comments]

Seeder lib for SQLAlchemy

<div class="md">every time i started a new fastapi project i was spending the first week doing the exact same stuff. jwt auth, sqlalchemy setup, alembic migrations, docker, celery for background tasks, stripe webhooks... it was just boring repetitive work. so i packaged everything into a template and have been using it across projects. setup takes like 10 mins and you get: <ul> <li>jwt auth with email verification and google/facebook social login</li> <li>stripe + webhooks already wired up</li> <li>postgresql + sqlalchemy + alembic migrations</li> <li>celery for background tasks</li> <li>docker config ready to deploy</li> <li>openai/langchain integration if you&#39;re building ai stuff</li> <li>pytest setup out of the box</li> </ul> 250+ apis deployed with it so far, works well across different cloud providers. been getting good feedback from other devs using it too. if anyone&#39;s interested: <a href="http://fastlaunchapi.dev">fastlaunchapi.dev</a> happy to answer questions about the stack or how anything is structured </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/fastlaunchapidev"> /u/fastlaunchapidev </a> <a href="https://www.reddit.com/r/FastAPI/comments/1s9h5nq/built_a_fastapi_boilerplate_so_i_stop_copy/">[link]</a> &#32; <a href="https://www.reddit.com/r/FastAPI/comments/1s9h5nq/built_a_fastapi_boilerplate_so_i_stop_copy/">[comments]</a>

every time i started a new fastapi project i was spending the first week doing the exact same stuff. jwt auth, sqlalchemy setup, alembic migrations, docker, celery for background tasks, stripe webhooks... it was just boring repetitive work.
 so i packaged everything into a template and have been using it across projects. setup takes like 10 mins and you get:
  
jwt auth with email verification and google/facebook social login
 stripe + webhooks already wired up
 postgresql + sqlalchemy + alembic migrations
 celery for background tasks
 docker config ready to deploy
 openai/langchain integration if you're building ai stuff
 pytest setup out of the box
  
250+ apis deployed with it so far, works well across different cloud providers. been getting good feedback from other devs using it too.
 if anyone's interested: fastlaunchapi.dev
 happy to answer questions about the stack or how anything is structured
    submitted by    /u/fastlaunchapidev  
 [link]   [comments]

built a fastapi boilerplate so i stop copy pasting the same setup every project

<table> <tr><td> <a href="https://www.reddit.com/r/FastAPI/comments/1scc7go/i_built_a_local_transcription_server_with_fastapi/"> <img src="https://preview.redd.it/g0lc6dyrz6tg1.gif?frame=1&amp;width=140&amp;height=75&amp;auto=webp&amp;s=8b382ede9c9937491e327f8253f36177bfcfa1c6" alt="I built a local transcription server with FastAPI and Faster-Whisper - Feedbacks are welcome!" title="I built a local transcription server with FastAPI and Faster-Whisper - Feedbacks are welcome!" /> </a> </td><td> <div class="md">I’ve always wanted a way to transcribe my meetings, lectures, and voice notes without sending private audio to cloud providers like Otter or OpenAI. I couldn&#39;t find a simple &quot;all-in-one&quot; self-hosted solution that handled Speaker Identification (who said what) out of the box, so I built AmicoScript. Processing img g0lc6dyrz6tg1... It’s a FastAPI-based web app that acts as a wrapper for OpenAI&#39;s Whisper and Pyannote. Main Features: <ul> <li>🔒 Privacy First: 100% local processing. No audio ever leaves your server.</li> <li>🐳 Docker Ready: Just <code>docker compose up --build</code> and it’s running on <code>localhost:8002</code>.</li> <li>👥 Speaker Diarization: Uses Pyannote to label &quot;Speaker 0&quot;, &quot;Speaker 1&quot;, etc. (Optional, requires a HuggingFace token).</li> <li>🚀 Performance: Supports models from <code>tiny</code> to <code>large-v3</code>. Background tasking ensures the UI doesn&#39;t freeze during long files.</li> <li>📄 Export Formats: Download results in TXT, SRT (for video subtitles), Markdown, or JSON.</li> <li>💾 Low Footprint: Temporary files are automatically cleaned up after 1 hour.</li> </ul> Tech Stack: <ul> <li>Backend: Python 3.10+, FastAPI.</li> <li>Frontend: Vanilla JS/HTML/CSS (Single-page app served by the backend, no complex build steps).</li> <li>Engine: Faster-Whisper &amp; Pyannote-audio.</li> </ul> I’m still refining the UI and would love some feedback from this community on how it runs on your home labs (NUCs, NAS, etc.). GitHub:<a href="https://github.com/sim186/AmicoScript">https://github.com/sim186/AmicoScript</a> A note on AI: I used LLMs to help accelerate the boilerplate and integration code, but I&#39;ve personally tested and debugged the threading and Docker logic to ensure it&#39;s stable for self-hosting. Happy to answer any questions about the setup! <a href="https://i.redd.it/g0lc6dyrz6tg1.gif">https://i.redd.it/g0lc6dyrz6tg1.gif</a> </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/seamoce"> /u/seamoce </a> <a href="https://www.reddit.com/r/FastAPI/comments/1scc7go/i_built_a_local_transcription_server_with_fastapi/">[link]</a> &#32; <a href="https://www.reddit.com/r/FastAPI/comments/1scc7go/i_built_a_local_transcription_server_with_fastapi/">[comments]</a> </td></tr></table>

I’ve always wanted a way to transcribe my meetings, lectures, and voice notes without sending private audio to cloud providers like Otter or OpenAI. I couldn't find a simple "all-in-one" self-hosted solution that handled Speaker Identification (who said what) out of the box, so I built AmicoScript.
 Processing img g0lc6dyrz6tg1...
 It’s a FastAPI-based web app that acts as a wrapper for OpenAI's Whisper and Pyannote.
 Main Features:
  
🔒 Privacy First: 100% local processing. No audio ever leaves your server.
 🐳 Docker Ready: Just docker compose up --build and it’s running on localhost:8002.
 👥 Speaker Diarization: Uses Pyannote to label "Speaker 0", "Speaker 1", etc. (Optional, requires a HuggingFace token).
 🚀 Performance: Supports models from tiny to large-v3. Background tasking ensures the UI doesn't freeze during long files.
 📄 Export Formats: Download results in TXT, SRT (for video subtitles), Markdown, or JSON.
 💾 Low Footprint: Temporary files are automatically cleaned up after 1 hour.
  
Tech Stack:
  
Backend: Python 3.10+, FastAPI.
 Frontend: Vanilla JS/HTML/CSS (Single-page app served by the backend, no complex build steps).
 Engine: Faster-Whisper & Pyannote-audio.
  
I’m still refining the UI and would love some feedback from this community on how it runs on your home labs (NUCs, NAS, etc.).
 GitHub:https://github.com/sim186/AmicoScript
 A note on AI: I used LLMs to help accelerate the boilerplate and integration code, but I've personally tested and debugged the threading and Docker logic to ensure it's stable for self-hosting.
 Happy to answer any questions about the setup!
 https://i.redd.it/g0lc6dyrz6tg1.gif
    submitted by    /u/seamoce  
 [link]   [comments]

I built a local transcription server with FastAPI and Faster-Whisper - Feedbacks are welcome!

<div class="md">Working on a scraping API built with FastAPI where clients submit batch jobs (up to 100 URLs) and need to receive results as they complete rather than waiting for the full batch. Currently using Server-Sent Events with StreamingResponse. The basic implementation works but running into some issues. Background task management: using asyncio tasks to run scrapers concurrently, but managing cancellation when clients disconnect is messy. Connection handling: if the client reconnects after a disconnect, they miss results that came through while disconnected. Thinking about buffering results in Redis with a job ID, but not sure how long to keep them. Error handling: individual URL failures shouldn&#39;t kill the stream. Currently wrapping each task in try/except and streaming error events, but the error format feels inconsistent. Progress tracking: clients want to know how many URLs are done vs pending vs failed. Sending a summary event every N completions works but feels hacky. Anyone built something similar with FastAPI SSE? Looking for patterns that work well in production, particularly around reconnection handling and clean shutdown. </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/SharpRule4025"> /u/SharpRule4025 </a> <a href="https://www.reddit.com/r/FastAPI/comments/1sc1tpk/streaming_scraping_job_results_with_fastapi_sse/">[link]</a> &#32; <a href="https://www.reddit.com/r/FastAPI/comments/1sc1tpk/streaming_scraping_job_results_with_fastapi_sse/">[comments]</a>

Working on a scraping API built with FastAPI where clients submit batch jobs (up to 100 URLs) and need to receive results as they complete rather than waiting for the full batch.
 Currently using Server-Sent Events with StreamingResponse. The basic implementation works but running into some issues.
 Background task management: using asyncio tasks to run scrapers concurrently, but managing cancellation when clients disconnect is messy.
 Connection handling: if the client reconnects after a disconnect, they miss results that came through while disconnected. Thinking about buffering results in Redis with a job ID, but not sure how long to keep them.
 Error handling: individual URL failures shouldn't kill the stream. Currently wrapping each task in try/except and streaming error events, but the error format feels inconsistent.
 Progress tracking: clients want to know how many URLs are done vs pending vs failed. Sending a summary event every N completions works but feels hacky.
 Anyone built something similar with FastAPI SSE? Looking for patterns that work well in production, particularly around reconnection handling and clean shutdown.
    submitted by    /u/SharpRule4025  
 [link]   [comments]

Streaming scraping job results with FastAPI SSE: what's the cleanest pattern?

<div class="md">Hi all, I&#39;d like to ask your opinions about my plan, and if you think it&#39;s bad, tell me what to do instead :P For context, first my environment: <ul> <li>FastAPI</li> <li>SQLModel (SQLAlchemy + Pydantic)</li> <li>Jinja2 (with HTMX)</li> <li>Auth via MS Azure App Service (middleware to get user group &amp; scopes from AD)</li> </ul> Our current templates duplicate some permission and state checking logic to determine if some action is available. The same checks happen when the request is actually made, the permission check via dependencies, the state check as business logic in the API route. I would like to eliminate the duplication by putting the state checks in a dependency as well. My thought is that I can extend the functionality of <code>url_for</code> to attempt to resolve the dependencies. I&#39;d make some kind of result object that holds either a reason for denial (for a tooltip etc) or the resolved action (verb + URL). The idea is that this would mean we can only write all needed checks once, as dependencies on API calls, and that the exact same calls are automatically used by the templates. At this point I&#39;d almost think it&#39;s worth making a small standalone module for. I looked but couldn&#39;t find something out there. An additional question: How do you handle differing permission scopes having (write) access to different fields on the same API? My ideas so far are: <ol> <li>Make multiple APIs. Becomes difficult as combinations grow, so doesn&#39;t seem scalable.</li> <li>Have a single model but use include/exclude based on dep (scope+state) at parse time.</li> <li>Having multiple models for 1 API based on dep(s).</li> <li>Having 1 model with all fields, but check field(s) with dep(s).</li> </ol> I guess this is the X of my XY problem, so If someone knows of some kind of library that can handle all/most of this and is easy to make work with our MS Azure App Service setup (i.e. a custom middleware for role retrieval), that would be even better. Thanks! </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/dries007"> /u/dries007 </a> <a href="https://www.reddit.com/r/FastAPI/comments/1s91hrw/resolving_dependencies_for_routes_in_jinja/">[link]</a> &#32; <a href="https://www.reddit.com/r/FastAPI/comments/1s91hrw/resolving_dependencies_for_routes_in_jinja/">[comments]</a>

Hi all, 
 I'd like to ask your opinions about my plan, and if you think it's bad, tell me what to do instead :P
 For context, first my environment:
  
FastAPI
 SQLModel (SQLAlchemy + Pydantic)
 Jinja2 (with HTMX)
 Auth via MS Azure App Service (middleware to get user group & scopes from AD)
  
Our current templates duplicate some permission and state checking logic to determine if some action is available. The same checks happen when the request is actually made, the permission check via dependencies, the state check as business logic in the API route.
 I would like to eliminate the duplication by putting the state checks in a dependency as well. My thought is that I can extend the functionality of url_for to attempt to resolve the dependencies. I'd make some kind of result object that holds either a reason for denial (for a tooltip etc) or the resolved action (verb + URL).
 The idea is that this would mean we can only write all needed checks once, as dependencies on API calls, and that the exact same calls are automatically used by the templates.
 At this point I'd almost think it's worth making a small standalone module for. I looked but couldn't find something out there.
 An additional question: How do you handle differing permission scopes having (write) access to different fields on the same API? My ideas so far are: 
  
Make multiple APIs. Becomes difficult as combinations grow, so doesn't seem scalable.
 Have a single model but use include/exclude based on dep (scope+state) at parse time.
 Having multiple models for 1 API based on dep(s).
 Having 1 model with all fields, but check field(s) with dep(s).
  
I guess this is the X of my XY problem, so If someone knows of some kind of library that can handle all/most of this and is easy to make work with our MS Azure App Service setup (i.e. a custom middleware for role retrieval), that would be even better.
 Thanks!
    submitted by    /u/dries007  
 [link]   [comments]

Resolving dependencies for routes in jinja templates to check api call eligibility, good idea?

<div class="md">I&#39;ve been working on <code>fastapi-views</code>, a library that brings Django REST Framework-style class-based views to FastAPI while keeping full type safety and dependency injection. The core idea: instead of wiring up individual route functions, you inherit from a view class and the library registers routes, status codes, and OpenAPI docs automatically — with correct HTTP semantics out of the box. It also ships with DRF-style filters, RFC 9457 Problem Details for error responses (with ready-to-use exception classes), and optional Prometheus metrics and OpenTelemetry tracing. It&#39;s not supposed to be a &quot;batteries-included&quot; / &quot;all-in-one&quot; framework like DRF — the package is not tied to any specific database/ORM, auth framework, or pattern. That said, I&#39;m considering implementing an auth layer and permission classes, as well as some optional SQLAlchemy integration. - Docs: <a href="https://asynq-io.github.io/fastapi-views/">https://asynq-io.github.io/fastapi-views/</a> - Source: <a href="https://github.com/asynq-io/fastapi-views">https://github.com/asynq-io/fastapi-views</a> - Install: `pip install fastapi-views` I&#39;ve been using it with success for a while now, so I thought I&#39;d share it here. If you&#39;ve been building APIs with FastAPI and found yourself copy-pasting the same patterns across projects, this might be worth a look. Happy to hear what features you&#39;d find most valuable, what&#39;s missing, or your thoughts on the project in general. If you like it, leaving a star would be appreciated. </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/SatisfactionScary663"> /u/SatisfactionScary663 </a> <a href="https://www.reddit.com/r/FastAPI/comments/1sc2xdo/fastapi_views_yet_another_class_based_views/">[link]</a> &#32; <a href="https://www.reddit.com/r/FastAPI/comments/1sc2xdo/fastapi_views_yet_another_class_based_views/">[comments]</a>

I've been working on fastapi-views, a library that brings Django REST Framework-style class-based views to FastAPI while keeping full type safety and dependency injection.
 The core idea: instead of wiring up individual route functions, you inherit from a view class and the library registers routes, status codes, and OpenAPI docs automatically — with correct HTTP semantics out of the box.
 It also ships with DRF-style filters, RFC 9457 Problem Details for error responses (with ready-to-use exception classes), and optional Prometheus metrics and OpenTelemetry tracing.
 It's not supposed to be a "batteries-included" / "all-in-one" framework like DRF — the package is not tied to any specific database/ORM, auth framework, or pattern. That said, I'm considering implementing an auth layer and permission classes, as well as some optional SQLAlchemy integration.
 - Docs: https://asynq-io.github.io/fastapi-views/
 - Source: https://github.com/asynq-io/fastapi-views
 - Install: `pip install fastapi-views`
 I've been using it with success for a while now, so I thought I'd share it here. If you've been building APIs with FastAPI and found yourself copy-pasting the same patterns across projects, this might be worth a look. Happy to hear what features you'd find most valuable, what's missing, or your thoughts on the project in general. If you like it, leaving a star would be appreciated.
    submitted by    /u/SatisfactionScary663  
 [link]   [comments]

FastAPI Views - yet another class based views library

<div class="md">Building a RAG-based appliance manual assistant. Works perfectly on localhost, breaks in production on Railway. Stack: FastAPI, Pinecone, SentenceTransformer, Groq, Cloudinary, MongoDB. Frontend on Vercel, backend + ml_service both on Railway as separate services. The full failure chain I traced: <ul> <li>Cloudinary env vars incomplete (only URL set, no API key/secret) → manual PDFs never uploaded</li> <li>No upload → no QR generated → nothing sent to ML service</li> <li>ML service never indexed anything into Pinecone</li> <li>RAG queries return empty every time</li> </ul> Cloudinary is fixed now. Still have these open questions: Problem 1 — 502 on upload processing ML service was loading SentenceTransformer synchronously on the request thread, Railway proxy was timing out. Fixed by moving to a global singleton + asyncio.to_thread inside BackgroundTasks. Is this the right pattern for heavy CPU tasks in FastAPI prod or is there a better approach? Problem 2 — Background task failures are silent If Pinecone is unreachable or OOM happens inside a BackgroundTask, MongoDB status stays &quot;processing&quot; forever. Currently wrapping everything in try/except and updating to &quot;failed&quot;. Is there a better observability pattern here — some kind of task result tracking without bringing in Celery? Problem 3 — Pinecone index object not JSON serializable Debug route was returning the Pinecone index object directly, got this: <pre><code>TypeError(&quot;&#39;_thread.RLock&#39; object is not iterable&quot;) </code></pre> Fixed by returning <code>index.describe_index_stats().to_dict()</code> instead. Posting in case it saves someone else time. Main question: Is eager-loading SentenceTransformer in a FastAPI startup event via <code>asyncio.to_thread</code> the right call on Railway to avoid cold start 502s? Any memory gotchas on the 512MB starter plan when OCR + embeddings are running simultaneously? </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/Legitimate_Scene226"> /u/Legitimate_Scene226 </a> <a href="https://www.reddit.com/r/FastAPI/comments/1sbdcxn/fastapi_ml_service_on_railway_backgroundtasks/">[link]</a> &#32; <a href="https://www.reddit.com/r/FastAPI/comments/1sbdcxn/fastapi_ml_service_on_railway_backgroundtasks/">[comments]</a>

Building a RAG-based appliance manual assistant. Works perfectly on localhost, breaks in production on Railway.
 Stack: FastAPI, Pinecone, SentenceTransformer, Groq, Cloudinary, MongoDB. Frontend on Vercel, backend + ml_service both on Railway as separate services.
 The full failure chain I traced:
  
Cloudinary env vars incomplete (only URL set, no API key/secret) → manual PDFs never uploaded
 No upload → no QR generated → nothing sent to ML service
 ML service never indexed anything into Pinecone
 RAG queries return empty every time
  
Cloudinary is fixed now. Still have these open questions:
 Problem 1 — 502 on upload processing ML service was loading SentenceTransformer synchronously on the request thread, Railway proxy was timing out. Fixed by moving to a global singleton + asyncio.to_thread inside BackgroundTasks. Is this the right pattern for heavy CPU tasks in FastAPI prod or is there a better approach?
 Problem 2 — Background task failures are silent If Pinecone is unreachable or OOM happens inside a BackgroundTask, MongoDB status stays "processing" forever. Currently wrapping everything in try/except and updating to "failed". Is there a better observability pattern here — some kind of task result tracking without bringing in Celery?
 Problem 3 — Pinecone index object not JSON serializable Debug route was returning the Pinecone index object directly, got this:
 TypeError("'_thread.RLock' object is not iterable") 
 Fixed by returning index.describe_index_stats().to_dict() instead. Posting in case it saves someone else time.
 Main question: Is eager-loading SentenceTransformer in a FastAPI startup event via asyncio.to_thread the right call on Railway to avoid cold start 502s? Any memory gotchas on the 512MB starter plan when OCR + embeddings are running simultaneously?
    submitted by    /u/Legitimate_Scene226  
 [link]   [comments]

Hello, Python

Python Jobs 💼

They want a data scientist + backend dev + ML engineer + DevOps person in one fresh graduate. 💀

Django Table, Filter and Export With Htmx

Built a Django app that turns documents into a knowledge graph and lets you query it

Django advanced conecpts

Django-modern-rest

Multi-tenant SaaS with django

Your Opinion on Full AI Coding

I rebuilt my self-hosted webhook scheduler (Cratos) after your feedback

Beginner in Django/Backend: I understand tutorials but freeze when building on my own. How do I improve?

Hardest migration in production you ever had to carry out?

So... Granular permissions? How to?

Are Old Django courses still relevant today?

Seeking honest code review — Django portfolio project (self-taught career changer, 80+ apps, 0 interviews)

Need advice on model designs

Hobby to Production app - What do I need to know?

My first page, focused on Lil Peep

ProxyForge - Solving IP Throttling

Run task on backend

I built a real-time debugging dashboard for Django (like Laravel Telescope)

Updating app in ever changing data requirements.

Django 5 By Example: Should I learn using this book in 2026?

Best way to handle multilingual messages (errors, success, notifications) in Django API with user-based language?

This is screenshots from django-scope. If you like it please leave a Star!

Finding tutorial for django and flask

I rebuilt my URL shortener (M-ini.me) after running it free for years ... would love your feedback

How can I monitor how many requests am I processing rn and how many are waiting?

flask db = Error: No such command 'db'

Simple bodyweight workout webapp

I built a real-time debugging dashboard for Django (like Laravel Telescope)

Would this level of backend project be enough to get shortlisted for a startup role?

How do you approach migrating VBA logic to Python (with APIs & auth)?

Learning Backend engineering with python django,What more should add to that guys?

How are you actually managing background/async tasks in FastAPI in production?

Trying to implement PATCH in FastAPI and Claude told me to use two separate Pydantic models — is this actually the way?

fastapi-watch — health checks, metrics, and a live dashboard for FastAPI in one registry call

Wireup for FastAPI now supports DI in background tasks

What's the best practice for exception handling in FastAPI?

Dynantic - A Pydantic-v2 ORM for DynamoDB (because I was tired of duplicating models)

Rate Limiting in FastAPI: What the Popular Libraries Miss

Built a production-ready FastAPI + LangGraph template for agent workflows (open source)

How do you know if your FastAPI BackgroundTasks actually ran?

Question on API Design

Seeder lib for SQLAlchemy

built a fastapi boilerplate so i stop copy pasting the same setup every project

I built a local transcription server with FastAPI and Faster-Whisper - Feedbacks are welcome!

Streaming scraping job results with FastAPI SSE: what's the cleanest pattern?

Resolving dependencies for routes in jinja templates to check api call eligibility, good idea?

FastAPI Views - yet another class based views library

FastAPI ML Service on Railway — BackgroundTasks + SentenceTransformer 502, Pinecone never getting indexed