<table> <tr><td> <a href="https://www.reddit.com/r/FastAPI/comments/1skqg35/fastapi_gives_you_the_spec_uigen_gives_you_the/"> <img src="https://preview.redd.it/ncjwz2rsb1vg1.gif?width=640&amp;crop=smart&amp;s=193e2b678e120f4f311befbccf6b15897bccaf57" alt="FastAPI gives you the spec. UIGen gives you the full React Frontend. Zero code." title="FastAPI gives you the spec. UIGen gives you the full React Frontend. Zero code." /> </a> </td><td> <div class="md">Hey everyone, I’m a huge fan of FastAPI. The fact that it generates an OpenAPI spec out of the box is its true superpower. But I noticed that while we get amazing documentation (Swagger UI / ReDoc) for free, we still have to manually build the internal tools, dashboards, and admin panels to actually use the data easily. So I built the other half of the equation. UIGen - point it at your FastAPI /openapi.json URL, and get a fully interactive React frontend in seconds. npx @uigen-dev/cli serve <a href="http://127.0.0.1:8000/openapi.json">http://127.0.0.1:8000/openapi.json</a> # UI is live at http://localhost:4400 <h1>How it fits the FastAPI ecosystem</h1> FastAPI is all about types and specs. UIGen follows that philosophy: <ol> <li>Pydantic Validation: Because your spec includes the constraints from your Pydantic models, UIGen automatically builds Zod validation on the frontend to match.</li> <li>Interactive, not just Docs: Swagger UI is for testing endpoints. UIGen is for managing resources. It handles the &quot;ListView -&gt; DetailView -&gt; EditForm&quot; flow as a cohesive app.</li> </ol> <h1>What it generates (from your FastAPI code)</h1> <ul> <li>Sidebar nav mapped to your API tags/resources.</li> <li>Smart Tables with sorting, pagination, and filtering (derived from your query params).</li> <li>Dynamic Forms derived from your Pydantic models.</li> <li>Detail Views with related resource links.</li> <li>Auth UI - handles Bearer tokens and credential injection via a built-in proxy.</li> <li>Wizards: Large models are automatically split into multi-step forms.</li> <li>Complex Actions: Non-CRUD endpoints show up as custom action buttons.</li> </ul> <h1>How it works</h1> It parses your /openapi.json into a custom Intermediate Representation (IR). A pre-built React SPA (shadcn/ui + TanStack) reads that IR and renders the UI. A Vite dev server serves the app and proxies API calls to your FastAPI backend, handling CORS headers so you don&#39;t have to fiddle with middleware during dev. <h1>Honest Limitations</h1> <ul> <li>Circular Models: If you have deeply nested recursive Pydantic models, resolution might skip the deepest levels.</li> <li>Edit View: Works best if you have a standard GET /{id} endpoint for your items.</li> <li>And many other edge cases.</li> </ul> <h1>Try it now</h1> If you have a FastAPI app running locally: npx @uigen-dev/cli serve http://localhost:8000/openapi.json Or try it on one of the example yaml files in the repo <ul> <li>GitHub: <a href="https://github.com/darula-hpp/uigen">https://github.com/darula-hpp/uigen</a></li> <li>npm: <a href="https://www.npmjs.com/package/@uigen-dev/cli">https://www.npmjs.com/package/@uigen-dev/cli</a></li> </ul> Would love to hear thoughts from the FastApi community. Of course, this isn&#39;t meant to replace a custom consumer-facing frontend, but for internal tools, rapid prototyping, or providing a UI for your API consumers, it’s a massive time-saver. Happy coding! </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/Prestigious-Bee2093"> /u/Prestigious-Bee2093 </a> <a href="https://i.redd.it/ncjwz2rsb1vg1.gif">[link]</a> &#32; <a href="https://www.reddit.com/r/FastAPI/comments/1skqg35/fastapi_gives_you_the_spec_uigen_gives_you_the/">[comments]</a> </td></tr></table>

Hey everyone,
 I’m a huge fan of FastAPI. The fact that it generates an OpenAPI spec out of the box is its true superpower. But I noticed that while we get amazing documentation (Swagger UI / ReDoc) for free, we still have to manually build the internal tools, dashboards, and admin panels to actually use the data easily.
 So I built the other half of the equation.
 UIGen - point it at your FastAPI /openapi.json URL, and get a fully interactive React frontend in seconds.
 npx @uigen-dev/cli serve http://127.0.0.1:8000/openapi.json
 # UI is live at http://localhost:4400
 How it fits the FastAPI ecosystem
 FastAPI is all about types and specs. UIGen follows that philosophy:
  
Pydantic Validation: Because your spec includes the constraints from your Pydantic models, UIGen automatically builds Zod validation on the frontend to match.
 Interactive, not just Docs: Swagger UI is for testing endpoints. UIGen is for managing resources. It handles the "ListView -> DetailView -> EditForm" flow as a cohesive app.
  
What it generates (from your FastAPI code)
  
Sidebar nav mapped to your API tags/resources.
 Smart Tables with sorting, pagination, and filtering (derived from your query params).
 Dynamic Forms derived from your Pydantic models.
 Detail Views with related resource links.
 Auth UI - handles Bearer tokens and credential injection via a built-in proxy.
 Wizards: Large models are automatically split into multi-step forms.
 Complex Actions: Non-CRUD endpoints show up as custom action buttons.
  
How it works
 It parses your /openapi.json into a custom Intermediate Representation (IR). A pre-built React SPA (shadcn/ui + TanStack) reads that IR and renders the UI. A Vite dev server serves the app and proxies API calls to your FastAPI backend, handling CORS headers so you don't have to fiddle with middleware during dev.
 Honest Limitations
  
Circular Models: If you have deeply nested recursive Pydantic models, resolution might skip the deepest levels.
 Edit View: Works best if you have a standard GET /{id} endpoint for your items.
 And many other edge cases.
  
Try it now
 If you have a FastAPI app running locally:
 npx @uigen-dev/cli serve http://localhost:8000/openapi.json
 Or try it on one of the example yaml files in the repo
  
GitHub: https://github.com/darula-hpp/uigen
 npm: https://www.npmjs.com/package/@uigen-dev/cli
  
Would love to hear thoughts from the FastApi community. Of course, this isn't meant to replace a custom consumer-facing frontend, but for internal tools, rapid prototyping, or providing a UI for your API consumers, it’s a massive time-saver.
 Happy coding!
    submitted by    /u/Prestigious-Bee2093  
 [link]   [comments]

FastAPI gives you the spec. UIGen gives you the full React Frontend. Zero code.

<table> <tr><td> <a href="https://www.reddit.com/r/FastAPI/comments/1sjbykw/opensource_fullstack_template_inspired_by_fastapi/"> <img src="https://preview.redd.it/h2jyqyc9jjug1.png?width=140&amp;height=70&amp;auto=webp&amp;s=61a6a5b4a5d9375827ef77bed24413a41e3f3a8c" alt="Open-Source Full-Stack Template inspired by FastAPI Template and Netflix's Dispatch" title="Open-Source Full-Stack Template inspired by FastAPI Template and Netflix's Dispatch" /> </a> </td><td> <div class="md">For educational and commercial purposes, I developed my minimalist full-stack template inspired by official FastAPI template and Netflix&#39;s Dispatch service. Backend: FastAPI, SQLAlchemy, Pydantic Frontend: React, Material UI, Nginx Link to live-demo: <a href="https://full-stack-template.xyz">https://full-stack-template.xyz</a> Github project: <a href="https://github.com/konverner/full-stack-template">https://github.com/konverner/full-stack-template</a> I have tried to respect the best practices of API and UI/UX design. I put sources in README for educational purposes. I have tested this template across 5 commercial projects, and I am (my clients are as well) satisfied with the results as for now. I would be happy share it with you and to hear feedback </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/StreetMedium6827"> /u/StreetMedium6827 </a> <a href="https://www.reddit.com/gallery/1sjbykw">[link]</a> &#32; <a href="https://www.reddit.com/r/FastAPI/comments/1sjbykw/opensource_fullstack_template_inspired_by_fastapi/">[comments]</a> </td></tr></table>

For educational and commercial purposes, I developed my minimalist full-stack template inspired by official FastAPI template and Netflix's Dispatch service.
 Backend: FastAPI, SQLAlchemy, Pydantic
 Frontend: React, Material UI, Nginx
 Link to live-demo: https://full-stack-template.xyz
 Github project: https://github.com/konverner/full-stack-template
 I have tried to respect the best practices of API and UI/UX design. I put sources in README for educational purposes.
 I have tested this template across 5 commercial projects, and I am (my clients are as well) satisfied with the results as for now.
 I would be happy share it with you and to hear feedback
    submitted by    /u/StreetMedium6827  
 [link]   [comments]

Open-Source Full-Stack Template inspired by FastAPI Template and Netflix's Dispatch

<div class="md">I’m currently using AWS lambda / APIGateway to host my FastAPI server. There’s a ton of code to make this work and other stuff that I’m the only person in my team understands. Had to switch from Mangin back to using uvicorn to serve because I wanted streamed responses, and to make things start fast we use Snapstart, which is also a whole thing. I was considering switching over to using Modal, but found out about FastAPI Cloud. Cloud sounds awesome, but I’m pretty sure I can replace my job system with function calls on Modal. I don’t see an equivalent out of the box job system managed by Cloud. Has anyone tried both? Any reason to use Cloud over Modal? Still too early to tell with Cloud? </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/MichaelEvo"> /u/MichaelEvo </a> <a href="https://www.reddit.com/r/FastAPI/comments/1sgrdo3/fastapi_cloud_vs_modal/">[link]</a> &#32; <a href="https://www.reddit.com/r/FastAPI/comments/1sgrdo3/fastapi_cloud_vs_modal/">[comments]</a>

I’m currently using AWS lambda / APIGateway to host my FastAPI server. There’s a ton of code to make this work and other stuff that I’m the only person in my team understands. Had to switch from Mangin back to using uvicorn to serve because I wanted streamed responses, and to make things start fast we use Snapstart, which is also a whole thing.
 I was considering switching over to using Modal, but found out about FastAPI Cloud. Cloud sounds awesome, but I’m pretty sure I can replace my job system with function calls on Modal. I don’t see an equivalent out of the box job system managed by Cloud.
 Has anyone tried both? Any reason to use Cloud over Modal? Still too early to tell with Cloud?
    submitted by    /u/MichaelEvo  
 [link]   [comments]

FastAPI Cloud vs Modal

<div class="md">Hi everyone, Since the last post I made for my module <code>fastapi-toolsets</code>, 2 major versions have passed and a lot of features have been added! I&#39;ve been busy improving the Crud module with fixes and new features: <ul> <li><code>OffsetPagination</code> and <code>CursorPagination</code> </li> <li>Unified Paginated (both offset and cursor pagination on the same endpoint) </li> <li>Faceted search, Sorting and Column search</li> </ul> I&#39;ve posted an article to demonstrate these new capabilities through a concrete example with offset and cursor pagination, full-text search, facet filtering, and client-driven sorting. Here&#39;s a quick overview of what it looks like: The core idea is a `CrudFactory` that acts as a single source of truth for what your API exposes: <code>python ArticleCrud = CrudFactory( model=Article, cursor_column=Article.created_at, searchable_fields=[Article.title, Article.body, (Article.category, Category.name)], facet_fields=[Article.status, (Article.category, Category.name)], order_fields=[Article.title, Article.created_at], ) </code> Routes then become thin wrappers, all query parameters (page, cursor, filters, search, ordering) are automatically handled by <code>paginate_params()</code>: <code>python @router.get(&quot;/articles&quot;) async def list_articles(session: SessionDep, params: Annotated[dict, Depends(ArticleCrud.paginate_params())]) -&gt; PaginatedResponse[ArticleRead]: return await ArticleCrud.paginate(session, **params, schema=ArticleRead) </code> This gives you offset and cursor pagination, search, filters, and sorting out of the box — with a single endpoint supporting both pagination strategies via a `pagination_type` query param. <h1>Links</h1> <ul> <li>Article: <a href="https://blog.d3vyce.fr/posts/how-to-implement-pagination-sorting-and-filtering-with-fastapi/">https://blog.d3vyce.fr/posts/how-to-implement-pagination-sorting-and-filtering-with-fastapi/</a></li> <li>GitHub: <a href="https://github.com/d3vyce/fastapi-toolsets">https://github.com/d3vyce/fastapi-toolsets</a></li> <li>Docs: <a href="https://fastapi-toolsets.d3vyce.fr">https://fastapi-toolsets.d3vyce.fr</a></li> <li>PyPI: <code>uv add fastapi-toolsets</code></li> </ul> Feedback welcome! </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/d3vyce"> /u/d3vyce </a> <a href="https://www.reddit.com/r/FastAPI/comments/1sgjrhd/how_to_implement_paginationsorting_and_filtering/">[link]</a> &#32; <a href="https://www.reddit.com/r/FastAPI/comments/1sgjrhd/how_to_implement_paginationsorting_and_filtering/">[comments]</a>

Hi everyone,
 Since the last post I made for my module fastapi-toolsets, 2 major versions have passed and a lot of features have been added!
 I've been busy improving the Crud module with fixes and new features:
  
OffsetPagination and CursorPagination
 
Unified Paginated (both offset and cursor pagination on the same endpoint)
 
Faceted search, Sorting and Column search
  
I've posted an article to demonstrate these new capabilities through a concrete example with offset and cursor pagination, full-text search, facet filtering, and client-driven sorting. Here's a quick overview of what it looks like:
 The core idea is a `CrudFactory` that acts as a single source of truth for what your API exposes:
 python ArticleCrud = CrudFactory( model=Article, cursor_column=Article.created_at, searchable_fields=[Article.title, Article.body, (Article.category, Category.name)], facet_fields=[Article.status, (Article.category, Category.name)], order_fields=[Article.title, Article.created_at], ) 
 Routes then become thin wrappers, all query parameters (page, cursor, filters, search, ordering) are automatically handled by paginate_params():
 python @router.get("/articles") async def list_articles(session: SessionDep, params: Annotated[dict, Depends(ArticleCrud.paginate_params())]) -> PaginatedResponse[ArticleRead]: return await ArticleCrud.paginate(session, **params, schema=ArticleRead) 
 This gives you offset and cursor pagination, search, filters, and sorting out of the box — with a single endpoint supporting both pagination strategies via a `pagination_type` query param.
 Links
  
Article: https://blog.d3vyce.fr/posts/how-to-implement-pagination-sorting-and-filtering-with-fastapi/
 
GitHub: https://github.com/d3vyce/fastapi-toolsets
 
Docs: https://fastapi-toolsets.d3vyce.fr
 
PyPI: uv add fastapi-toolsets
 
 Feedback welcome!
    submitted by    /u/d3vyce  
 [link]   [comments]

How to implement pagination,sorting and filtering with fastapi? FastAPI-Toolsets v3.0

<div class="md">I just got the invite to FASTAPI Cloud, however after reviewing the documentation I’m still not sure who will be responsible for hosting the front-end client server that runs on localhost:3000. From the documentation, my understanding is that FASTAPI Cloud will host the python back-end server that runs the REST API, but it does not mention anything about a JavaScript client server hosting. How and where should I deploy the client server to have a production like application hosting? </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/imdshizzle"> /u/imdshizzle </a> <a href="https://www.reddit.com/r/FastAPI/comments/1sgblrm/who_will_host_the_application_client_server_with/">[link]</a> &#32; <a href="https://www.reddit.com/r/FastAPI/comments/1sgblrm/who_will_host_the_application_client_server_with/">[comments]</a>

I just got the invite to FASTAPI Cloud, however after reviewing the documentation I’m still not sure who will be responsible for hosting the front-end client server that runs on localhost:3000. From the documentation, my understanding is that FASTAPI Cloud will host the python back-end server that runs the REST API, but it does not mention anything about a JavaScript client server hosting. How and where should I deploy the client server to have a production like application hosting?
    submitted by    /u/imdshizzle  
 [link]   [comments]

Who will host the application client server with FASTAPI Cloud?

<div class="md">I got tired of Easy-RSA and built FastPKI: a fully async, API-driven PKI management system on top of FastAPI + SQLModel GitHub: <a href="https://github.com/jsenecal/fastpki">https://github.com/jsenecal/fastpki</a> Docs: <a href="https://jsenecal.github.io/fastpki/">https://jsenecal.github.io/fastpki/</a> What it does: <ul> <li>Create and manage Certificate Authorities with intermediate CA hierarchies and path length constraints</li> <li>Issue and revoke server, client, and CA certificates via a clean RESTful API</li> <li>Multi-tenant via organizations, with RBAC (SUPERUSER / ADMIN / USER) and per-user capability flags for fine-grained cert operations</li> <li>SQLite for dev, PostgreSQL + asyncpg for prod</li> <li>Alembic migrations, Docker + Compose support, pre-built GHCR image</li> </ul> Stack: <ul> <li>FastAPI + SQLModel (async throughout with aiosqlite/asyncpg)</li> <li>Pydantic v2, Alembic, cryptography lib</li> <li>uv for packaging, ruff for linting/formatting, mypy for type checking</li> <li>279 tests, ~90% coverage</li> </ul> Built with Claude Code, but not totally vibecoded - every design decision was intentional and it&#39;s battle-tested in a real production telecom environment. The permission model, CA hierarchy constraints, and async DB layer were all deliberate choices. Currently at v0.3.5. Feedback and PRs welcome. </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/mstrsmth"> /u/mstrsmth </a> <a href="https://www.reddit.com/r/FastAPI/comments/1slcy9l/i_did_a_thing_fastpki_a_proper_rest_api_for_pki/">[link]</a> &#32; <a href="https://www.reddit.com/r/FastAPI/comments/1slcy9l/i_did_a_thing_fastpki_a_proper_rest_api_for_pki/">[comments]</a>

I got tired of Easy-RSA and built FastPKI: a fully async, API-driven PKI management system on top of FastAPI + SQLModel
 GitHub: https://github.com/jsenecal/fastpki Docs: https://jsenecal.github.io/fastpki/
 What it does:
  
Create and manage Certificate Authorities with intermediate CA hierarchies and path length constraints
 Issue and revoke server, client, and CA certificates via a clean RESTful API
 Multi-tenant via organizations, with RBAC (SUPERUSER / ADMIN / USER) and per-user capability flags for fine-grained cert operations
 SQLite for dev, PostgreSQL + asyncpg for prod
 Alembic migrations, Docker + Compose support, pre-built GHCR image
  
Stack:
  
FastAPI + SQLModel (async throughout with aiosqlite/asyncpg)
 Pydantic v2, Alembic, cryptography lib
 uv for packaging, ruff for linting/formatting, mypy for type checking
 279 tests, ~90% coverage
  
Built with Claude Code, but not totally vibecoded - every design decision was intentional and it's battle-tested in a real production telecom environment. The permission model, CA hierarchy constraints, and async DB layer were all deliberate choices.
 Currently at v0.3.5. Feedback and PRs welcome.
    submitted by    /u/mstrsmth  
 [link]   [comments]

I did a thing: FastPKI - A proper REST API for PKI management (Easy-RSA alternative)

<div class="md">I wanted high speed communication between multiple scripts of mine. Long ago i had started to use fastapi for that purpose and then i just got into modular monolithic architecture for web UIs. but then as i kept doing things i didnt feel like that is satisfactory recently i was kinda intrested to build native applications and wanted IPC and i googled it first didnt find anything simple enough for me to just use out of the box. like grpc too complex i tried using it once but was complex for my use case and added unnecessary friction. and then to go for simpler microservice architecture rather than multiple fastapi servers/workers in future for my web uis i thought wont this be simpler and have come out with a simpler library for making a more microservices kinda architecture and just wrap the calls in fastapi for distributed. With regular setups it kinda gets more complex to implement IPC this library abstracts a lot of that and makes it feel almost like fastapi on provider side and on consumer side it somewhat like requests. With my current system i believe it is simpler to build Fully distributed mircoservices and then use them through a single fastapi server. Like i can have 10 seperate services which all do different things and then u can have a fastapi server which send requests to differnt process on same device or distributed and just use them without worrying about how to communicate and you can restart any microservice and it wont matter to the fastapi server, if you use load balanced events then you can even have 0 downtime updates to code. I have added support for: - events (RPC like) - streaming (streaming RPC calls) - pub/sub (1-&gt;many) - groups (load balanced events) - full pydantic integration - IPC to HTTP using fastapi I tried some benchmarking and have got like sub ms latencies | Metric | Mean | Median | P95 | P99 | |----------------------------|----------|----------|----------|----------| | RPC Latency (RTT) | 0.32ms | 0.29ms | 0.60ms | 0.66ms | | Group Latency (LB RTT) | 0.30ms | 0.29ms | 0.36ms | 0.55ms | | PubSub Latency (Relay) | 18.50ms | 19.36ms | 21.76ms | 21.91ms | | Throughput Metric | Result | |----------------------------|------------------------| | RPC Throughput | 8551.8 calls/sec | | Group Throughput (LB) | 8877.5 calls/sec | | Streaming Throughput | 12278.6 chunks/sec | I wanted better performance while being simpler than regular web stack and have benchmarked my lib and have gotten decent results id say the benchmark scripts are in the repo you may check them out have added some example scripts on how you may want to implement things (check out examples/decoupled_demo) almost like fastapi but just IPC <a href="https://github.com/shashstormer/comm_ipc/tree/master">https://github.com/shashstormer/comm_ipc/tree/master</a> <a href="https://www.reddit.com/submit/?source_id=t3_1sieray&amp;composer_entry=crosspost_prompt"></a> </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/shashstormer"> /u/shashstormer </a> <a href="https://www.reddit.com/r/FastAPI/comments/1sii2is/commipc_a_typesafe_asynchronous_ipc_library_for/">[link]</a> &#32; <a href="https://www.reddit.com/r/FastAPI/comments/1sii2is/commipc_a_typesafe_asynchronous_ipc_library_for/">[comments]</a>

I wanted high speed communication between multiple scripts of mine.
 Long ago i had started to use fastapi for that purpose and then i just got into modular monolithic architecture for web UIs.
 but then as i kept doing things i didnt feel like that is satisfactory recently i was kinda intrested to build native applications and wanted IPC and i googled it first didnt find anything simple enough for me to just use out of the box.
 like grpc too complex i tried using it once but was complex for my use case and added unnecessary friction.
 and then to go for simpler microservice architecture rather than multiple fastapi servers/workers in future for my web uis i thought wont this be simpler and have come out with a simpler library for making a more microservices kinda architecture and just wrap the calls in fastapi for distributed.
 With regular setups it kinda gets more complex to implement IPC this library abstracts a lot of that and makes it feel almost like fastapi on provider side and on consumer side it somewhat like requests.
 With my current system i believe it is simpler to build Fully distributed mircoservices and then use them through a single fastapi server.
 Like i can have 10 seperate services which all do different things and then u can have a fastapi server which send requests to differnt process on same device or distributed and just use them without worrying about how to communicate and you can restart any microservice and it wont matter to the fastapi server, if you use load balanced events then you can even have 0 downtime updates to code.
 I have added support for:
 - events (RPC like)
 - streaming (streaming RPC calls)
 - pub/sub (1->many)
 - groups (load balanced events)
 - full pydantic integration
 - IPC to HTTP using fastapi
 I tried some benchmarking and have got like sub ms latencies
 | Metric | Mean | Median | P95 | P99 |
 |----------------------------|----------|----------|----------|----------|
 | RPC Latency (RTT) | 0.32ms | 0.29ms | 0.60ms | 0.66ms |
 | Group Latency (LB RTT) | 0.30ms | 0.29ms | 0.36ms | 0.55ms |
 | PubSub Latency (Relay) | 18.50ms | 19.36ms | 21.76ms | 21.91ms |
 | Throughput Metric | Result |
 |----------------------------|------------------------|
 | RPC Throughput | 8551.8 calls/sec |
 | Group Throughput (LB) | 8877.5 calls/sec |
 | Streaming Throughput | 12278.6 chunks/sec |
 I wanted better performance while being simpler than regular web stack
 and have benchmarked my lib and have gotten decent results id say
 the benchmark scripts are in the repo you may check them out
 have added some example scripts on how you may want to implement things (check out examples/decoupled_demo) almost like fastapi but just IPC
 https://github.com/shashstormer/comm_ipc/tree/master
 
    submitted by    /u/shashstormer  
 [link]   [comments]

CommIPC: A type-safe, asynchronous IPC library for Python (FastAPI for IPC)

<div class="md">Hello everyone, I am currently running my business off a VPS running WooCommerce. I am unhappy with the limitations of WordPress, and want to look into Django. I have a pretty good understanding of Python, and I am not in a hurry to switch. Is there any framework for e-commerce that works within Django? I have looked online, and by the looks of it, I&#39;d have to build all the e-commerce functionality myself. I might be misinformed, simply because I don&#39;t know Django at all. Anyone have any insight into how to go about this? Where would efforts best be spent in educating myself. </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/Ducking_eh"> /u/Ducking_eh </a> <a href="https://www.reddit.com/r/djangolearning/comments/1sgxevq/ecommerce_on_django/">[link]</a> &#32; <a href="https://www.reddit.com/r/djangolearning/comments/1sgxevq/ecommerce_on_django/">[comments]</a>

Hello everyone,
 I am currently running my business off a VPS running WooCommerce.
 I am unhappy with the limitations of WordPress, and want to look into Django.
 I have a pretty good understanding of Python, and I am not in a hurry to switch.
 Is there any framework for e-commerce that works within Django?
 I have looked online, and by the looks of it, I'd have to build all the e-commerce functionality myself. I might be misinformed, simply because I don't know Django at all.
 Anyone have any insight into how to go about this? Where would efforts best be spent in educating myself.
    submitted by    /u/Ducking_eh  
 [link]   [comments]

E-commerce on django

<div class="md">Has anyone tried hosting django on vercel, especially in April 2026 after they started supporting it? What do you think? </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/Puzzleheaded_Ear2351"> /u/Puzzleheaded_Ear2351 </a> <a href="https://www.reddit.com/r/djangolearning/comments/1sl7y6f/django_on_vercel/">[link]</a> &#32; <a href="https://www.reddit.com/r/djangolearning/comments/1sl7y6f/django_on_vercel/">[comments]</a>

Has anyone tried hosting django on vercel, especially in April 2026 after they started supporting it? What do you think?
    submitted by    /u/Puzzleheaded_Ear2351  
 [link]   [comments]

Django on vercel

<div class="md">I&#39;ve been building in Django for a long time and I love the framework, but some things have always bugged me: <ul> <li>Typing is exceptionally painful...and getting proper type safety across a Django project is a fight</li> <li>the ORM leaks throughout your project: it&#39;s easy to chain ORM methods in a view, a serializer, a template tag, a Celery task, etc and N+1s end up being difficult to find</li> <li>models become god objects: custom managers, <code>save</code> overrides, signal handlers, computed properties, validation logic, your models attract everything until they&#39;re 500 lines of tangled responsibilities.</li> <li>tests become slow over time because you either hit the DB for everything or mock too aggressively: this is because there&#39;s no clear encapsulated layers.</li> </ul> and a ton of other stuff including aesthetics... Anyway, the short version of my solution is to push all ORM work into repositories that return Pydantic DTOs. Services get repos via constructor injection and contain pure business logic with zero model imports. Your views become one-liners. Every layer boundary is typed, and each layer is independently testable. Some of the opinions: <ul> <li>Prefixed ULID primary keys: double-clickable Stripe-style IDs like <code>ord_01jq3v</code>... on every model.</li> <li>Models are dumb but aesthetic: <code>Meta</code> first, fields in a strict order (identifiers, times, status, domain, relations), all indexes and constraints declared explicitly in <code>Meta</code>, zero business logic.</li> <li>Repositories return DTOs, never querysets so the ORM never leaks past this layer. This is where 90% of Django&#39;s typing hassles end.</li> <li>Services own the business logic injected via <a href="https://svcs.hynek.me/">https://svcs.hynek.me</a>, tested without a database by mocking the repo. This makes tests super fast and composable.</li> <li>Thin django-ninja routes give you input validation and OpenAPI for free, handlers are just calling services <code>get(MyService).do_thing()</code> in a DI-esque way.</li> <li>Reliable signals via Celery side-effects enqueued inside the DB transaction so rollbacks are respected. This gets us pretty close to a DBOS or Temporal. Adapted from <a href="https://hakibenita.com/django-reliable-signals">https://hakibenita.com/django-reliable-signals</a>.</li> <li>Three test layers the repos test against a real DB, service against mocked repos, API through mocked services. This keeps the tests fast and clean.</li> </ul> Disclaimer: These are super opinionated. They won&#39;t be everyone&#39;s cup of tea, and that&#39;s fine. But they&#39;ve held up well on large-scale projects and I thought they might be useful to others who are looking for a clean way to structure Django beyond the &quot;everything in views.py&quot; stage. </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/danielvf"> /u/danielvf </a> <a href="https://github.com/dvf/opinionated-django">[link]</a> &#32; <a href="https://www.reddit.com/r/django/comments/1sk8yam/after_15_years_of_building_production_django_apps/">[comments]</a>

I've been building in Django for a long time and I love the framework, but some things have always bugged me:
  
Typing is exceptionally painful...and getting proper type safety across a Django project is a fight
 the ORM leaks throughout your project: it's easy to chain ORM methods in a view, a serializer, a template tag, a Celery task, etc and N+1s end up being difficult to find
 models become god objects: custom managers, save overrides, signal handlers, computed properties, validation logic, your models attract everything until they're 500 lines of tangled responsibilities.
 tests become slow over time because you either hit the DB for everything or mock too aggressively: this is because there's no clear encapsulated layers.
  
and a ton of other stuff including aesthetics...
 Anyway, the short version of my solution is to push all ORM work into repositories that return Pydantic DTOs. Services get repos via constructor injection and contain pure business logic with zero model imports. Your views become one-liners. Every layer boundary is typed, and each layer is independently testable.
 Some of the opinions:
  
Prefixed ULID primary keys: double-clickable Stripe-style IDs like ord_01jq3v... on every model.
 Models are dumb but aesthetic: Meta first, fields in a strict order (identifiers, times, status, domain, relations), all indexes and constraints declared explicitly in Meta, zero business logic.
 Repositories return DTOs, never querysets so the ORM never leaks past this layer. This is where 90% of Django's typing hassles end.
 Services own the business logic injected via https://svcs.hynek.me, tested without a database by mocking the repo. This makes tests super fast and composable.
 Thin django-ninja routes give you input validation and OpenAPI for free, handlers are just calling services get(MyService).do_thing() in a DI-esque way.
 Reliable signals via Celery side-effects enqueued inside the DB transaction so rollbacks are respected. This gets us pretty close to a DBOS or Temporal. Adapted from https://hakibenita.com/django-reliable-signals.
 Three test layers the repos test against a real DB, service against mocked repos, API through mocked services. This keeps the tests fast and clean.
  
Disclaimer: These are super opinionated. They won't be everyone's cup of tea, and that's fine. But they've held up well on large-scale projects and I thought they might be useful to others who are looking for a clean way to structure Django beyond the "everything in views.py" stage.
    submitted by    /u/danielvf  
 [link]   [comments]

After 15 years of building production Django apps, these are the patterns I keep using... (packaged as Agent skills)

<div class="md">So in my past webapp that I built which was a forum type app I used Flask in python for backend but I decided to try and learn Django and it is incredibly easier. I mean it handles all of the auth and database management while also giving access to an admin dashboard. I feel like it leaves almost no room for javascript but I am also a fairly rookie coder and rely a lot on AI so please correct me if I am wrong. </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/VirtualParsnip3789"> /u/VirtualParsnip3789 </a> <a href="https://www.reddit.com/r/django/comments/1sgbg3q/just_started_using_django_feels_too_good_to_be/">[link]</a> &#32; <a href="https://www.reddit.com/r/django/comments/1sgbg3q/just_started_using_django_feels_too_good_to_be/">[comments]</a>

So in my past webapp that I built which was a forum type app I used Flask in python for backend but I decided to try and learn Django and it is incredibly easier. I mean it handles all of the auth and database management while also giving access to an admin dashboard. I feel like it leaves almost no room for javascript but I am also a fairly rookie coder and rely a lot on AI so please correct me if I am wrong. 
    submitted by    /u/VirtualParsnip3789  
 [link]   [comments]

Just started using django, feels too good to be true.

<div class="md">I&#39;ve been working on <a href="https://github.com/djust-org/djust">djust</a> for a while and just wrapped up the 0.4 series, so figured I&#39;d share where things are at. The short version: it&#39;s a Phoenix LiveView-style framework for Django. You write Python, get reactive UIs over WebSocket. A Rust VDOM engine handles the diffing and DOM patching. No API layer, no React/Vue, no webpack. Here&#39;s what a basic view looks like: <pre><code>class CounterView(LiveView): template_name = &quot;counter.html&quot; def mount(self, request, **kwargs): self.count = 0 @event_handler def increment(self, **kwargs): self.count += 1 &lt;h1&gt;{{ count }}&lt;/h1&gt; &lt;button dj-click=&quot;increment&quot;&gt;+1&lt;/button&gt; </code></pre> Click the button, count updates over WebSocket. That&#39;s it. The big additions in 0.4 were around making common UI patterns work without writing any JavaScript. So now you can do stuff like: <pre><code>&lt;input dj-input=&quot;search&quot; dj-debounce=&quot;300&quot;&gt; &lt;div dj-shortcut=&quot;ctrl+k:open_search, escape:close_modal&quot;&gt; &lt;button dj-click=&quot;save&quot; dj-disable-with=&quot;Saving...&quot; dj-lock&gt; &lt;div dj-click-away=&quot;close_dropdown&quot;&gt; </code></pre> Debounce, throttle, keyboard shortcuts, click-away, disable-with. All just HTML attributes. We also added the ability for the server to push JS commands to the browser directly: <pre><code>@event_handler def open_panel(self, **kwargs): self.push_commands( JS.add_class(&quot;active&quot;, to=&quot;#panel&quot;) .focus(&quot;#search-input&quot;) ) </code></pre> Built on top of that, there&#39;s a <code>TutorialMixin</code> that lets you define a guided onboarding tour as a Python list and the framework handles all the highlighting, positioning, and step progression. Probably overkill for most apps but it was a fun way to prove out the server-driven UI primitives. The other big chunk of work was stability. About 15 bug fixes for things people actually hit when building real apps: private attributes getting wiped between WebSocket events, Python types like <code>set()</code> and <code>Decimal</code> failing to serialize, VDOM patcher edge cases. Each one has regression tests now. For the next release (0.5), we&#39;re working on a component/templating system with pre-built UI pieces and an auth system, which should make it a lot more practical to start a new project without wiring everything up yourself. Full writeup on the 0.4 features: <a href="https://djust.org/blog/djust-0-4-0-release/">blog post</a> <pre><code>pip install djust python -m djust startproject mysite </code></pre> <a href="https://github.com/djust-org/djust">GitHub</a> · <a href="https://djust.org/docs/">Docs</a> · <a href="https://djust.org/examples/">Examples</a> </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/jrtipton2"> /u/jrtipton2 </a> <a href="https://www.reddit.com/r/django/comments/1skdjv7/djust_04_phoenix_liveview_for_django_powered_by/">[link]</a> &#32; <a href="https://www.reddit.com/r/django/comments/1skdjv7/djust_04_phoenix_liveview_for_django_powered_by/">[comments]</a>

I've been working on djust for a while and just wrapped up the 0.4 series, so figured I'd share where things are at.
 The short version: it's a Phoenix LiveView-style framework for Django. You write Python, get reactive UIs over WebSocket. A Rust VDOM engine handles the diffing and DOM patching. No API layer, no React/Vue, no webpack.
 Here's what a basic view looks like:
 class CounterView(LiveView): template_name = "counter.html" def mount(self, request, **kwargs): self.count = 0 @event_handler def increment(self, **kwargs): self.count += 1 <h1>{{ count }}</h1> <button dj-click="increment">+1</button> 
 Click the button, count updates over WebSocket. That's it.
 The big additions in 0.4 were around making common UI patterns work without writing any JavaScript. So now you can do stuff like:
 <input dj-input="search" dj-debounce="300"> <div dj-shortcut="ctrl+k:open_search, escape:close_modal"> <button dj-click="save" dj-disable-with="Saving..." dj-lock> <div dj-click-away="close_dropdown"> 
 Debounce, throttle, keyboard shortcuts, click-away, disable-with. All just HTML attributes.
 We also added the ability for the server to push JS commands to the browser directly:
 @event_handler def open_panel(self, **kwargs): self.push_commands( JS.add_class("active", to="#panel") .focus("#search-input") ) 
 Built on top of that, there's a TutorialMixin that lets you define a guided onboarding tour as a Python list and the framework handles all the highlighting, positioning, and step progression. Probably overkill for most apps but it was a fun way to prove out the server-driven UI primitives.
 The other big chunk of work was stability. About 15 bug fixes for things people actually hit when building real apps: private attributes getting wiped between WebSocket events, Python types like set() and Decimal failing to serialize, VDOM patcher edge cases. Each one has regression tests now.
 For the next release (0.5), we're working on a component/templating system with pre-built UI pieces and an auth system, which should make it a lot more practical to start a new project without wiring everything up yourself.
 Full writeup on the 0.4 features: blog post
 pip install djust python -m djust startproject mysite 
 GitHub · Docs · Examples
 submitted by /u/jrtipton2 
 [link] [comments]

djust 0.4 — Phoenix LiveView for Django, powered by Rust. Reactive UIs in pure Python, no JS build step.

<div class="md">Hey everyone, Fullstack dev here. If you’re like me, you probably love the Django Admin. It’s the &quot;killer feature&quot; that makes Django so productive. But as soon as you move to a decoupled frontend (React/Vue/Svelte) and a REST API (DRF), you lose that &quot;instant UI&quot; magic and end up rebuilding the same CRUD tables and forms over and over. I built something to bring that &quot;instant UI&quot; workflow to any API, regardless of the backend. UIGen - point it at your OpenAPI spec (generated by drf-spectacular or similar), and get a fully interactive React frontend in seconds. npx @uigen-dev/cli serve ./openapi.yaml # UI is live at http://localhost:4400 <h1>Why use this if I have Django Admin?</h1> Django Admin is amazing, but it’s tied to the DB and server-side templates. UIGen is different: <ol> <li>Decoupled: It talks to your API endpoints, respecting your DRF serializers, permissions, and business logic.</li> <li>Modern SPA: It’s a full React SPA (shadcn/ui + TanStack Table) that feels like a premium SaaS product.</li> <li>Framework Agnostic: Today it’s React, but since it uses a custom Intermediate Representation (IR), I&#39;m already working on Svelte and Vue renderers. Same spec, different frontend stack.</li> </ol> <h1>How it works</h1> It parses your spec and converts it into an Intermediate Representation (IR) , a typed description of your resources, operations, schemas, auth, and relationships. A pre-built React SPA reads that IR and renders the appropriate views. A Vite dev server serves the SPA and proxies API calls to your real backend, handling CORS and Auth injection automatically. <h1>What it generates</h1> <ul> <li>Sidebar nav auto-built from your resources.</li> <li>Table views with sorting, pagination, and filtering.</li> <li>Create/edit forms with Zod validation (derived from your schema).</li> <li>Detail views with related resource links.</li> <li>Auth flows </li> </ul> - <ul> <li>Bearer, API Key, HTTP Basic, and even full credential-based login detection.</li> <li>Custom action buttons for non-CRUD endpoints (e.g., POST /orders/{id}/cancel).</li> <li>Dashboard with resource counts.</li> </ul> <h1>Current Limitation</h1> <ul> <li>Circular Refs: Deeply nested circular $refs may degrade gracefully rather than resolving perfectly.</li> <li>Edit Pre-population: Requires a GET /resource/{id} endpoint.</li> <li>Sub-resources: Parent-child navigation is currently focused on the detail pages.</li> <li>Pixel Perfect: It’s not a design tool; it’s a functional, professional tool.</li> <li>**And many other edge cases.</li> </ul> <h1>Try it on your DRF API</h1> If you use drf-spectacular, just download your schema and run: npx @uigen-dev/cli serve ./schema.yaml <ul> <li>GitHub: <a href="https://github.com/darula-hpp/uigen">https://github.com/darula-hpp/uigen</a></li> <li>npm: <a href="https://www.npmjs.com/package/@uigen-dev/cli">https://www.npmjs.com/package/@uigen-dev/cli</a></li> </ul> Would love to hear thoughts from the Django community. Of course, this isn&#39;t meant to replace a custom consumer-facing frontend, but for internal tools, rapid prototyping, or providing a UI for your API consumers, it’s a massive time-saver. Happy coding! </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/Prestigious-Bee2093"> /u/Prestigious-Bee2093 </a> <a href="https://i.redd.it/nr44n65s71vg1.gif">[link]</a> &#32; <a href="https://www.reddit.com/r/django/comments/1skpx37/django_admin_but_for_any_api_i_built_a_tool_that/">[comments]</a>

Hey everyone,
 Fullstack dev here. If you’re like me, you probably love the Django Admin. It’s the "killer feature" that makes Django so productive. But as soon as you move to a decoupled frontend (React/Vue/Svelte) and a REST API (DRF), you lose that "instant UI" magic and end up rebuilding the same CRUD tables and forms over and over.
 I built something to bring that "instant UI" workflow to any API, regardless of the backend.
 UIGen - point it at your OpenAPI spec (generated by drf-spectacular or similar), and get a fully interactive React frontend in seconds.
 npx @uigen-dev/cli serve ./openapi.yaml
 # UI is live at http://localhost:4400
 Why use this if I have Django Admin?
 Django Admin is amazing, but it’s tied to the DB and server-side templates. UIGen is different:
  
Decoupled: It talks to your API endpoints, respecting your DRF serializers, permissions, and business logic.
 Modern SPA: It’s a full React SPA (shadcn/ui + TanStack Table) that feels like a premium SaaS product.
 Framework Agnostic: Today it’s React, but since it uses a custom Intermediate Representation (IR), I'm already working on Svelte and Vue renderers. Same spec, different frontend stack.
  
How it works
 It parses your spec and converts it into an Intermediate Representation (IR) , a typed description of your resources, operations, schemas, auth, and relationships. A pre-built React SPA reads that IR and renders the appropriate views. A Vite dev server serves the SPA and proxies API calls to your real backend, handling CORS and Auth injection automatically.
 What it generates
  
Sidebar nav auto-built from your resources.
 Table views with sorting, pagination, and filtering.
 Create/edit forms with Zod validation (derived from your schema).
 Detail views with related resource links.
 Auth flows 
  
- 
  
Bearer, API Key, HTTP Basic, and even full credential-based login detection.
 Custom action buttons for non-CRUD endpoints (e.g., POST /orders/{id}/cancel).
 Dashboard with resource counts.
  
Current Limitation
  
Circular Refs: Deeply nested circular $refs may degrade gracefully rather than resolving perfectly.
 Edit Pre-population: Requires a GET /resource/{id} endpoint.
 Sub-resources: Parent-child navigation is currently focused on the detail pages.
 Pixel Perfect: It’s not a design tool; it’s a functional, professional tool.
 **And many other edge cases.
  
Try it on your DRF API
 If you use drf-spectacular, just download your schema and run:
 npx @uigen-dev/cli serve ./schema.yaml
  
GitHub: https://github.com/darula-hpp/uigen
 npm: https://www.npmjs.com/package/@uigen-dev/cli
  
Would love to hear thoughts from the Django community. Of course, this isn't meant to replace a custom consumer-facing frontend, but for internal tools, rapid prototyping, or providing a UI for your API consumers, it’s a massive time-saver.
 Happy coding!
    submitted by    /u/Prestigious-Bee2093  
 [link]   [comments]

Django Admin but for any API? I built a tool that generates a React frontend from an OpenAPI spec.

<div class="md">Trying to get a clearer picture of what people are actually running for background task processing in Django projects right now. Celery has been the go-to answer for so long that it&#39;s worth asking whether that&#39;s still the right first choice or just habit at this point. For smaller projects, Celery is a lot of infrastructure for what might be a handful of async tasks. Redis or RabbitMQ as a broker, worker processes to manage, monitoring to configure — it works, but it&#39;s not lightweight. Django-Q and Huey come up as alternatives and seem more self-contained, but it&#39;s hard to get a real sense of how they hold up under any meaningful load without having run them in production. Django 4.x also brought native async improvements, which raises the question of how much people are actually leaning on that versus still reaching for a dedicated task queue. Native async probably doesn&#39;t replace a proper queue for scheduled jobs or retries, but curious whether that assumption holds for people who&#39;ve dug into it. What are people actually running in production right now? Is Celery still the obvious answer for most use cases, or are there setups where something lighter genuinely holds up? And for anyone who has switched away from Celery — what drove that decision and was it worth it? </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/alexstrehlke"> /u/alexstrehlke </a> <a href="https://www.reddit.com/r/django/comments/1sljrcn/how_are_you_handling_background_tasks_in_django/">[link]</a> &#32; <a href="https://www.reddit.com/r/django/comments/1sljrcn/how_are_you_handling_background_tasks_in_django/">[comments]</a>

Trying to get a clearer picture of what people are actually running for background task processing in Django projects right now. Celery has been the go-to answer for so long that it's worth asking whether that's still the right first choice or just habit at this point.
 For smaller projects, Celery is a lot of infrastructure for what might be a handful of async tasks. Redis or RabbitMQ as a broker, worker processes to manage, monitoring to configure — it works, but it's not lightweight. Django-Q and Huey come up as alternatives and seem more self-contained, but it's hard to get a real sense of how they hold up under any meaningful load without having run them in production.
 Django 4.x also brought native async improvements, which raises the question of how much people are actually leaning on that versus still reaching for a dedicated task queue. Native async probably doesn't replace a proper queue for scheduled jobs or retries, but curious whether that assumption holds for people who've dug into it.
 What are people actually running in production right now? Is Celery still the obvious answer for most use cases, or are there setups where something lighter genuinely holds up? And for anyone who has switched away from Celery — what drove that decision and was it worth it?
    submitted by    /u/alexstrehlke  
 [link]   [comments]

How are you handling background tasks in Django right now — is Celery still the default?

<div class="md">in your opinion, what are the best and worst patterns to have in Django projects ? I’ve worked in many projects with different approaches: business logic in services classes; repository, many small functions to compound the business logic (one file with thousands of lines); business logic in models level; and use the built-in Django resources (mangers, forms and custom fields, class based views,custom middleware and so on). (Edit) I feel Django is very opinionated and some patterns from the industry doesn’t match with Django projects. I’ve worked in a legacy without any pattern (actually use many different at the same time :/ ). I liked the Django way to do the things, but I would like to hear the other point of view </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/dfbaggins"> /u/dfbaggins </a> <a href="https://www.reddit.com/r/django/comments/1sienmc/what_are_the_best_and_worst_patterns_to_have_in/">[link]</a> &#32; <a href="https://www.reddit.com/r/django/comments/1sienmc/what_are_the_best_and_worst_patterns_to_have_in/">[comments]</a>

in your opinion, what are the best and worst patterns to have in Django projects ? I’ve worked in many projects with different approaches: business logic in services classes; repository, many small functions to compound the business logic (one file with thousands of lines); business logic in models level; and use the built-in Django resources (mangers, forms and custom fields, class based views,custom middleware and so on).
 (Edit)
 I feel Django is very opinionated and some patterns from the industry doesn’t match with Django projects. I’ve worked in a legacy without any pattern (actually use many different at the same time :/ ). I liked the Django way to do the things, but I would like to hear the other point of view 
    submitted by    /u/dfbaggins  
 [link]   [comments]

what are the best and worst patterns to have in Django projects?

<div class="md">&quot;How do you debug N+1 queries in your Django views? Do you use debug-toolbar, just read logs, or something else?&quot; </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/Organic_Release1028"> /u/Organic_Release1028 </a> <a href="https://www.reddit.com/r/django/comments/1sfnm5h/how_do_you_debug_n1_queries_in_your_django_views/">[link]</a> &#32; <a href="https://www.reddit.com/r/django/comments/1sfnm5h/how_do_you_debug_n1_queries_in_your_django_views/">[comments]</a>

"How do you debug N+1 queries in your Django views? Do you use debug-toolbar, just read logs, or something else?"
    submitted by    /u/Organic_Release1028  
 [link]   [comments]

How do you debug N+1 queries in your Django views?

<div class="md">I’ve been working on a side project where developers can collaborate on the same project in real time (shared code editor, chat, etc.). The hardest part wasn’t the UI or even Git integration — it was real-time communication. A few things I learned (the hard way): WebSockets work great locally, but production is a different story → timeouts, dropped connections, reverse proxies… everything breaks differently Keeping multiple users in sync is harder than expected → even something simple like a shared editor can create race conditions You need to think about limits early → max payload size, number of participants, memory usage → otherwise you’re basically opening yourself to abuse Debugging real-time systems is painful → logs are not enough, you need good visibility of events I ended up restructuring part of the backend just to handle rooms, connections and cleanup properly. Still far from perfect, but it’s starting to work with real users now (~140). If anyone’s curious, this is what I’m building: <a href="https://www.codekhub.it/">https://www.codekhub.it/</a> </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/Heavy_Association633"> /u/Heavy_Association633 </a> <a href="https://www.reddit.com/r/django/comments/1sftkhb/what_i_learned_building_realtime_collaboration/">[link]</a> &#32; <a href="https://www.reddit.com/r/django/comments/1sftkhb/what_i_learned_building_realtime_collaboration/">[comments]</a>

I’ve been working on a side project where developers can collaborate on the same project in real time (shared code editor, chat, etc.).
 The hardest part wasn’t the UI or even Git integration — it was real-time communication.
 A few things I learned (the hard way):
 WebSockets work great locally, but production is a different story
 → timeouts, dropped connections, reverse proxies… everything breaks differently
 Keeping multiple users in sync is harder than expected
 → even something simple like a shared editor can create race conditions
 You need to think about limits early
 → max payload size, number of participants, memory usage
 → otherwise you’re basically opening yourself to abuse
 Debugging real-time systems is painful
 → logs are not enough, you need good visibility of events
 I ended up restructuring part of the backend just to handle rooms, connections and cleanup properly.
 Still far from perfect, but it’s starting to work with real users now (~140).
 If anyone’s curious, this is what I’m building:
 https://www.codekhub.it/
    submitted by    /u/Heavy_Association633  
 [link]   [comments]

What I learned building real-time collaboration (WebSockets, FastAPI, scaling issues)

<div class="md">Hi everyone, This might be a bit of a dumb question, but I’d really appreciate some guidance. I’m building a Django application and I’d like to assign users an ID that is: - human-readable (not something super long or messy like a UUID) - but also not easy to guess or enumerate I know Django already has primary keys and UUIDs, but I’m trying to find a balance between usability and security. For example, something shorter and cleaner than a UUID, but still reasonably safe to expose (e.g. in URLs or tickets). What would be the best approach for this? - Custom generated IDs - Hashing or encoding - Using UUIDs but formatting them differently Also, I know this might not be the best idea from a security standpoint, so feel free to point that out, I’m still learning and just want to understand the right approach. Thanks a lot! </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/accountant856"> /u/accountant856 </a> <a href="https://www.reddit.com/r/django/comments/1sfoqzi/how_do_you_generate_short_but_hardtoguess_user/">[link]</a> &#32; <a href="https://www.reddit.com/r/django/comments/1sfoqzi/how_do_you_generate_short_but_hardtoguess_user/">[comments]</a>

Hi everyone,
 This might be a bit of a dumb question, but I’d really appreciate some guidance.
 I’m building a Django application and I’d like to assign users an ID that is:
 - human-readable (not something super long or messy like a UUID)
 - but also not easy to guess or enumerate
 I know Django already has primary keys and UUIDs, but I’m trying to find a balance between usability and security. For example, something shorter and cleaner than a UUID, but still reasonably safe to expose (e.g. in URLs or tickets).
 What would be the best approach for this?
 - Custom generated IDs
 - Hashing or encoding
 - Using UUIDs but formatting them differently
 Also, I know this might not be the best idea from a security standpoint, so feel free to point that out, I’m still learning and just want to understand the right approach.
 Thanks a lot!
    submitted by    /u/accountant856  
 [link]   [comments]

How do you generate short but hard-to-guess user IDs in Django?

<div class="md">Hey there, I have done some tutorials around Django, but never coded a real app myself. As far as we have AI now, I&#39;m using it to code and learn while I do a sideproject. I&#39;m using BMAD method to help me and the agent architect propose this: <a href="https://preview.redd.it/9aznt8yx9rug1.png?width=560&amp;format=png&amp;auto=webp&amp;s=5af2bfa860b75de2efd9a065ad00d88ac2314d00">https://preview.redd.it/9aznt8yx9rug1.png?width=560&amp;format=png&amp;auto=webp&amp;s=5af2bfa860b75de2efd9a065ad00d88ac2314d00</a> I always listen that views should be thin and not carry business logics, but never understood how it would work, now I got this approach proposed by AI. Does it make sense? If not, where is the bad smell that I&#39;m not seen yet? The stack is: - Python 3.14 - Django 6.0 - HTMX - Django-q2 - Tailwind CSS </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/ph_dct"> /u/ph_dct </a> <a href="https://www.reddit.com/r/django/comments/1sjdpwo/is_this_servicepy_pattern_a_good_approach/">[link]</a> &#32; <a href="https://www.reddit.com/r/django/comments/1sjdpwo/is_this_servicepy_pattern_a_good_approach/">[comments]</a>

Hey there, 
 I have done some tutorials around Django, but never coded a real app myself. 
 As far as we have AI now, I'm using it to code and learn while I do a sideproject.
 I'm using BMAD method to help me and the agent architect propose this:
 https://preview.redd.it/9aznt8yx9rug1.png?width=560&format=png&auto=webp&s=5af2bfa860b75de2efd9a065ad00d88ac2314d00
 I always listen that views should be thin and not carry business logics, but never understood how it would work, now I got this approach proposed by AI. 
 Does it make sense? If not, where is the bad smell that I'm not seen yet?
 The stack is:
 - Python 3.14
 - Django 6.0
 - HTMX
 - Django-q2
 - Tailwind CSS
    submitted by    /u/ph_dct  
 [link]   [comments]

Is this "service.py" pattern a good approach?

<div class="md">Has some one used json datatype in any relational db? if so how efficient it worked? </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/No_Character_2277"> /u/No_Character_2277 </a> <a href="https://www.reddit.com/r/django/comments/1siaemt/json_in_relational_db/">[link]</a> &#32; <a href="https://www.reddit.com/r/django/comments/1siaemt/json_in_relational_db/">[comments]</a>

Has some one used json datatype in any relational db? if so how efficient it worked?
    submitted by    /u/No_Character_2277  
 [link]   [comments]

Json in relational db

<div class="md">I&#39;m a Computer Science student and for our pseudo-internship, we are taking over another team&#39;s Django website. It uses Django as back end and another framework as front end. In the code that returns database information, I see: <code>from django_filters.rest_framework import DjangoFilterBackend, FilterSet</code> <code>from rest_framework import filters</code> this is in addition to normal QuerySet() filters in the model code. While there are separate documentation for all 3, I wonder if experts here can explain why all 3 are needed (or maybe not needed but preferred). </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/AyrtonHS"> /u/AyrtonHS </a> <a href="https://www.reddit.com/r/django/comments/1sh78sj/is_there_a_need_for_3_filtering_systems/">[link]</a> &#32; <a href="https://www.reddit.com/r/django/comments/1sh78sj/is_there_a_need_for_3_filtering_systems/">[comments]</a>

I'm a Computer Science student and for our pseudo-internship, we are taking over another team's Django website. It uses Django as back end and another framework as front end.
 In the code that returns database information, I see:
 from django_filters.rest_framework import DjangoFilterBackend, FilterSet
 from rest_framework import filters
 this is in addition to normal QuerySet() filters in the model code. While there are separate documentation for all 3, I wonder if experts here can explain why all 3 are needed (or maybe not needed but preferred).
    submitted by    /u/AyrtonHS  
 [link]   [comments]

Is there a need for 3 filtering "systems"?

<div class="md">Made a small Django app for Stripe-style IDs. The main thing is your endpoints can accept multiple identifiers (UUID, slug, etc) for the same object. In a bigger API you always end up with the “wrong” ID in logs/admin/urls and have to translate it. This removes that step. No extra queries, just works with Django + DRF. GitHub: <a href="https://github.com/josephabrahams/django-display-ids">https://github.com/josephabrahams/django-display-ids</a> </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/josephabrahams"> /u/josephabrahams </a> <a href="https://pypi.org/project/django-display-ids/">[link]</a> &#32; <a href="https://www.reddit.com/r/django/comments/1sfwif9/stripelike_prefixed_ids_for_django_uuidslug/">[comments]</a>

Made a small Django app for Stripe-style IDs. The main thing is your endpoints can accept multiple identifiers (UUID, slug, etc) for the same object.
 In a bigger API you always end up with the “wrong” ID in logs/admin/urls and have to translate it. This removes that step. No extra queries, just works with Django + DRF.
 GitHub: https://github.com/josephabrahams/django-display-ids
    submitted by    /u/josephabrahams  
 [link]   [comments]

Stripe-like prefixed IDs for Django (+ uuid/slug support)

<div class="md">I built a restaurant POS/ERP backend as my first serious Django project. It started as a learning exercise but ended up more complex than expected. Looking for feedback before I start applying for jobs. **Stack:** Django 6, PostgreSQL, Celery, Redis Streams, DRF, HTMX **What it does:** - Multi-tenant (multiple restaurant orgs, fully scoped) - Order lifecycle with status FSM (draft → paid → refunded/cancelled) - FIFO inventory with `select_for_update` row locking - Recipe system — prepared products deduct ingredients on sale - eKasa integration — actual Slovak fiscal API (NineDigit), async via Celery + Redis Streams device command outbox - Cashier UI (HTMX), shift management, cash drawer tracking - Accounting entries split by tender type (cash vs card) - 316 tests **What I&#39;m unsure about:** - Is my service layer structure reasonable? Logic lives in `apps/orders/logic/`, `apps/payments/logic/` etc. - The async fiscal flow feels over-engineered — DeviceCommand outbox → Celery → eKasa API. Is this pattern sensible or am I solving a problem that doesn&#39;t exist? - Anything that would get this rejected immediately in a real code review Repo: <a href="https://github.com/rednaxela1813/rest-erp.git">https://github.com/rednaxela1813/rest-erp.git</a> I understand perfectly well that there&#39;s still a lot of work to do on this project. This is just the beginning... True, it took almost five months... But I&#39;m getting smarter as I go! I&#39;m job hunting for a junior/mid Python backend role. Brutal honesty appreciated. <h1></h1> UPDATE — April 2026: acted on the feedback After posting I did a proper code review session and found several real bugs: Bugs fixed: <ul> <li>Cash payments were silently missing from the accounting ledger — <code>record_sale</code> was only called in the card path, not in <code>_confirm_cash_payment</code>. Added a regression test.</li> <li><code>record_stock_out</code> was called twice on every sale — once inside <code>deduct_stock</code>, once in <code>finalize_paid_order</code>. Neutralized by <code>get_or_create</code> idempotency, but conceptually wrong.</li> <li>Celery periodic tasks were calling subtasks with <code>.run()</code> instead of <code>.delay()</code> — all <code>*_for_all_orgs</code> tasks were running synchronously, defeating the point of async workers.</li> <li><code>inspect.signature</code> hack in <code>OrderDetailApi</code> — was detecting actor parameter at runtime instead of just fixing the signatures.</li> </ul> Other improvements: <ul> <li>Production security settings added to <a href="http://prod.py"><code>prod.py</code></a> (HSTS, SSL redirect, secure cookies) — Django&#39;s <code>--deploy</code> check now passes clean.</li> <li>Runtime artifacts (<code>celerybeat-schedule*</code>) added to <code>.gitignore</code>.</li> </ul> Still a work in progress, but shipping fixes feels better than just shipping code. </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/CuteEnd7049"> /u/CuteEnd7049 </a> <a href="https://www.reddit.com/r/django/comments/1sipjws/django_poserp_backend_looking_for_honest_review/">[link]</a> &#32; <a href="https://www.reddit.com/r/django/comments/1sipjws/django_poserp_backend_looking_for_honest_review/">[comments]</a>

I built a restaurant POS/ERP backend as my first serious Django project. It started as a learning exercise but ended up more complex than expected. Looking for feedback before I start applying for jobs.
 **Stack:** Django 6, PostgreSQL, Celery, Redis Streams, DRF, HTMX
 **What it does:**
 - Multi-tenant (multiple restaurant orgs, fully scoped)
 - Order lifecycle with status FSM (draft → paid → refunded/cancelled)
 - FIFO inventory with `select_for_update` row locking
 - Recipe system — prepared products deduct ingredients on sale
 - eKasa integration — actual Slovak fiscal API (NineDigit), async via Celery + Redis Streams device command outbox
 - Cashier UI (HTMX), shift management, cash drawer tracking
 - Accounting entries split by tender type (cash vs card)
 - 316 tests
 **What I'm unsure about:**
 - Is my service layer structure reasonable? Logic lives in `apps/orders/logic/`, `apps/payments/logic/` etc.
 - The async fiscal flow feels over-engineered — DeviceCommand outbox → Celery → eKasa API. Is this pattern sensible or am I solving a problem that doesn't exist?
 - Anything that would get this rejected immediately in a real code review
 Repo: https://github.com/rednaxela1813/rest-erp.git
 I understand perfectly well that there's still a lot of work to do on this project. This is just the beginning... True, it took almost five months... But I'm getting smarter as I go!
 I'm job hunting for a junior/mid Python backend role. Brutal honesty appreciated.
 
 UPDATE — April 2026: acted on the feedback
 After posting I did a proper code review session and found several real bugs:
 Bugs fixed:
  
Cash payments were silently missing from the accounting ledger — record_sale was only called in the card path, not in _confirm_cash_payment. Added a regression test.
 record_stock_out was called twice on every sale — once inside deduct_stock, once in finalize_paid_order. Neutralized by get_or_create idempotency, but conceptually wrong.
 Celery periodic tasks were calling subtasks with .run() instead of .delay() — all *_for_all_orgs tasks were running synchronously, defeating the point of async workers.
 inspect.signature hack in OrderDetailApi — was detecting actor parameter at runtime instead of just fixing the signatures.
  
Other improvements:
  
Production security settings added to prod.py (HSTS, SSL redirect, secure cookies) — Django's --deploy check now passes clean.
 Runtime artifacts (celerybeat-schedule*) added to .gitignore.
  
Still a work in progress, but shipping fixes feels better than just shipping code.
    submitted by    /u/CuteEnd7049  
 [link]   [comments]

Django POS/ERP backend — looking for honest review before job hunting

<div class="md">Hey everyone, I’ve been working on <a href="https://github.com/manjurulhoque/trip-nest">Trip Nest</a> — a hotel booking-style platform with a Django REST API and a Next.js dashboard. What it does <ul> <li>Search and browse hotels with filters</li> <li>Hotel details: rooms, facilities, photos, location</li> <li>Bookings: guest flows for upcoming and past trips</li> <li>Accounts: JWT auth, guest/host roles, host verification, wishlists</li> <li>Admin-side pieces for managing catalog and properties</li> <li>OpenAPI docs at <code>/api/docs/</code> and <code>/api/redoc/</code></li> </ul> Observability The backend exports traces over OTLP HTTP (default <code>http://localhost:4318/v1/traces</code>) so you can point it at <a href="https://www.jaegertracing.io/">Jaeger</a> or any compatible collector. Logs are structured JSON (via structlog) and can include trace/span IDs when a request is traced, so you can jump from logs to traces in Jaeger UI (e.g. <code>http://localhost:16686</code> if you run the all-in-one container). Stack Backend: Django + DRF · Frontend: Next.js · Auth: JWT (access/refresh) · Tracing: OpenTelemetry → OTLP → Jaeger Repo: <a href="https://github.com/manjurulhoque/trip-nest">https://github.com/manjurulhoque/trip-nest</a> Happy to hear how others wire OTEL/Jaeger in dev vs prod, or any feedback on the API or UX. Thanks for reading. </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/manjurulhoque"> /u/manjurulhoque </a> <a href="https://www.reddit.com/gallery/1skhyhc">[link]</a> &#32; <a href="https://www.reddit.com/r/django/comments/1skhyhc/trip_nest_hotel_booking_with_django_nextjs_and/">[comments]</a>

Hey everyone,
 I’ve been working on Trip Nest — a hotel booking-style platform with a Django REST API and a Next.js dashboard.
 What it does
  
Search and browse hotels with filters
 Hotel details: rooms, facilities, photos, location
 Bookings: guest flows for upcoming and past trips
 Accounts: JWT auth, guest/host roles, host verification, wishlists
 Admin-side pieces for managing catalog and properties
 OpenAPI docs at /api/docs/ and /api/redoc/
  
Observability
 The backend exports traces over OTLP HTTP (default http://localhost:4318/v1/traces) so you can point it at Jaeger or any compatible collector. Logs are structured JSON (via structlog) and can include trace/span IDs when a request is traced, so you can jump from logs to traces in Jaeger UI (e.g. http://localhost:16686 if you run the all-in-one container).
 Stack
 Backend: Django + DRF · Frontend: Next.js · Auth: JWT (access/refresh) · Tracing: OpenTelemetry → OTLP → Jaeger
 Repo: https://github.com/manjurulhoque/trip-nest
 Happy to hear how others wire OTEL/Jaeger in dev vs prod, or any feedback on the API or UX.
 Thanks for reading.
    submitted by    /u/manjurulhoque  
 [link]   [comments]

Trip Nest — hotel booking with Django, Next.js, and OpenTelemetry + Jaeger

<div class="md">Who do you use for transactional emails like confirming email address, password resets, etc? I&#39;d eventually like to send email invites through my app. I&#39;m leaning towards Sender, Resend, Mailtrap, or Brevo. I considered SES and as a dev I think I could figure out the setup, but I&#39;ve read stories of people getting rejected from using it in production. </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/1si0ms6/transactional_email/">[link]</a> &#32; <a href="https://www.reddit.com/r/django/comments/1si0ms6/transactional_email/">[comments]</a>

Who do you use for transactional emails like confirming email address, password resets, etc? I'd eventually like to send email invites through my app. I'm leaning towards Sender, Resend, Mailtrap, or Brevo. I considered SES and as a dev I think I could figure out the setup, but I've read stories of people getting rejected from using it in production. 
    submitted by    /u/nuevedientes  
 [link]   [comments]

Transactional email

<div class="md">I built a demo Django project showing one approach to enterprise SSO for multi-tenant apps. It is not self-promotion, the code is production tested. Perhaps it&#39;ll be useful for somebody as it took me a couple of months to implement. Instead of implementing separate auth flows for each provider, the app uses AWS Cognito as an identity broker. Django still owns the app-side concerns: tenant config, callback handling, user/account membership, role mapping, and deprovisioning behavior. Included in the repo: <ul> <li>email-domain-based SSO config lookup</li> <li>Cognito callback flow in Django</li> <li>Azure AD and Okta support</li> <li>provider/app client provisioning via backend APIs</li> <li>external role/group mapping into app roles</li> <li>webhook/event handling for user lifecycle changes</li> <li>test coverage for the auth flow</li> </ul> Repo: <a href="http://github.com/soldatov-ss/django-cognito-sso-demo">github.com/soldatov-ss/django-cognito-sso-demo</a> It’s meant as a reference implementation rather than a generic library. The documentation of how to do it you will find in the github repo (series of 6 articles) </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/Ok_Researcher_6962"> /u/Ok_Researcher_6962 </a> <a href="https://www.reddit.com/r/django/comments/1sk5ft4/built_a_django_reference_app_for_multitenant_sso/">[link]</a> &#32; <a href="https://www.reddit.com/r/django/comments/1sk5ft4/built_a_django_reference_app_for_multitenant_sso/">[comments]</a>

I built a demo Django project showing one approach to enterprise SSO for multi-tenant apps.
 It is not self-promotion, the code is production tested.
 Perhaps it'll be useful for somebody as it took me a couple of months to implement.
 Instead of implementing separate auth flows for each provider, the app uses AWS Cognito as an identity broker. Django still owns the app-side concerns: tenant config, callback handling, user/account membership, role mapping, and deprovisioning behavior.
 Included in the repo:
  
email-domain-based SSO config lookup
 Cognito callback flow in Django
 Azure AD and Okta support
 provider/app client provisioning via backend APIs
 external role/group mapping into app roles
 webhook/event handling for user lifecycle changes
 test coverage for the auth flow
  
Repo: github.com/soldatov-ss/django-cognito-sso-demo
 It’s meant as a reference implementation rather than a generic library.
 The documentation of how to do it you will find in the github repo (series of 6 articles)
    submitted by    /u/Ok_Researcher_6962  
 [link]   [comments]

Built a Django reference app for multi-tenant SSO with Cognito, Azure AD, and Okta

<div class="md">Hi everyone. I&#39;m a junior developer (2.5 YOE) working mostly solo for a small US-based startup, and I&#39;ve recently been running up against the issue of &quot;chains of events&quot; in Django, and would like to see how more experienced folks deal with it, and also learn whether it&#39;s a system design fault on my part or just one of the types of problems Django isn&#39;t best suited to handle. For context: the application integrates with several different external services; Stripe is the main one (it&#39;s a marketplace platform), and also other services for other types of payments, marketing, AWS services for notifications, geolocation data management, etc. We also support Organizations, with multiple users with different roles within them. When a user signs up, a bunch of things need to happen at the same time, including creating accounts on the various third-party services we use. I&#39;ve worked to keep most of the signup context data needed within regular Django models, for simplicity, but there are specific onboarding paths where I just cannot avoid having to create a Stripe Express account, _then_ a Service X account, _then_ an AWS SNS topic, etc. This creates a lengthy and brittle chain where if a single step fails, the user/organization ends up incorrectly configured, and is unable to use specific features of the platform. I also do not have much visibility into this process (poor observability configs on my part) and so I&#39;m often at a loss when something goes wrong. I&#39;m aware of atomic transactions, and while they help a lot, they do not make dealing with this chain concept easier. I&#39;m wondering how larger applications handle this. Do they move to an event-driven system instead of a monolithic one like what Django is meant for? How do they deal with third-party retries in lengthy onboarding flows? And how do you improve observability into this process, to aid debugging? Thanks in advance for your advice! </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/PyJacker16"> /u/PyJacker16 </a> <a href="https://www.reddit.com/r/django/comments/1sjm21s/dealing_with_side_effects_and_sequential_tasks_in/">[link]</a> &#32; <a href="https://www.reddit.com/r/django/comments/1sjm21s/dealing_with_side_effects_and_sequential_tasks_in/">[comments]</a>

Hi everyone. I'm a junior developer (2.5 YOE) working mostly solo for a small US-based startup, and I've recently been running up against the issue of "chains of events" in Django, and would like to see how more experienced folks deal with it, and also learn whether it's a system design fault on my part or just one of the types of problems Django isn't best suited to handle.
 For context: the application integrates with several different external services; Stripe is the main one (it's a marketplace platform), and also other services for other types of payments, marketing, AWS services for notifications, geolocation data management, etc. We also support Organizations, with multiple users with different roles within them.
 When a user signs up, a bunch of things need to happen at the same time, including creating accounts on the various third-party services we use. I've worked to keep most of the signup context data needed within regular Django models, for simplicity, but there are specific onboarding paths where I just cannot avoid having to create a Stripe Express account, _then_ a Service X account, _then_ an AWS SNS topic, etc. 
 This creates a lengthy and brittle chain where if a single step fails, the user/organization ends up incorrectly configured, and is unable to use specific features of the platform. I also do not have much visibility into this process (poor observability configs on my part) and so I'm often at a loss when something goes wrong. I'm aware of atomic transactions, and while they help a lot, they do not make dealing with this chain concept easier.
 I'm wondering how larger applications handle this. Do they move to an event-driven system instead of a monolithic one like what Django is meant for? How do they deal with third-party retries in lengthy onboarding flows? And how do you improve observability into this process, to aid debugging?
 Thanks in advance for your advice!
    submitted by    /u/PyJacker16  
 [link]   [comments]

Dealing with side effects and sequential tasks in Django

<div class="md">Hello, I was wondering if it makes sense to have migrations in .gitignore files during development. This was suggested by a team member but problems with migrations keeps arising. </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/AyrtonHS"> /u/AyrtonHS </a> <a href="https://www.reddit.com/r/django/comments/1sl5mkv/migrations_in_gitignore_during_development/">[link]</a> &#32; <a href="https://www.reddit.com/r/django/comments/1sl5mkv/migrations_in_gitignore_during_development/">[comments]</a>

Hello, I was wondering if it makes sense to have migrations in .gitignore files during development. This was suggested by a team member but problems with migrations keeps arising. 
    submitted by    /u/AyrtonHS  
 [link]   [comments]

Migrations in .gitignore during development

<div class="md">Estoy buscando un lugar donde charlar, donde emocionarse con los nuevos features, donde plantear ideas y hacer comunidad, donde podamos pensar en una app y hacerla en algunas tardes solo para probar cosas. Un lugar donde quizá no sea para aprender de 0, algo más para compartir formas de trabajo, ideas, cómo resolver problemas grandes, y poder ejercer el Rubber Duck pero con personas, ayudar en proyectos, algún lugar donde nos podamos sentar a programar. ¿Habrá alguna? Este sub es muy interesante, pero creo que estaría bien poder hacer incluso retos de x cosas y ver las diversas formas de resolverlo. </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/Jolly-Play3558"> /u/Jolly-Play3558 </a> <a href="https://www.reddit.com/r/django/comments/1sheywl/existe_algún_discord_con_comunidad_activa_sobre/">[link]</a> &#32; <a href="https://www.reddit.com/r/django/comments/1sheywl/existe_algún_discord_con_comunidad_activa_sobre/">[comments]</a>

Estoy buscando un lugar donde charlar, donde emocionarse con los nuevos features, donde plantear ideas y hacer comunidad, donde podamos pensar en una app y hacerla en algunas tardes solo para probar cosas. Un lugar donde quizá no sea para aprender de 0, algo más para compartir formas de trabajo, ideas, cómo resolver problemas grandes, y poder ejercer el Rubber Duck pero con personas, ayudar en proyectos, algún lugar donde nos podamos sentar a programar.
 ¿Habrá alguna?
 Este sub es muy interesante, pero creo que estaría bien poder hacer incluso retos de x cosas y ver las diversas formas de resolverlo.
    submitted by    /u/Jolly-Play3558  
 [link]   [comments]

¿Existe algún discord con comunidad activa sobre django en español?

&#32; submitted by &#32; <a href="https://www.reddit.com/user/thibaudcolas"> /u/thibaudcolas </a> <a href="https://wagtail.org/blog/ai-and-developer-experience-wagtail-community-survey/">[link]</a> &#32; <a href="https://www.reddit.com/r/django/comments/1shllo3/ai_and_developer_experience_wagtail_community/">[comments]</a>

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

AI and Developer Experience: Wagtail community survey

<div class="md">It runs 3 mini-games at the same time (math, pattern memory, and a grid where you identify the dominant color). Each one has its own timer while also sharing a global timer, so you have to manage everything under time pressure. There’s also a simple ranking system and player profiles. Here’s a short gameplay video for context: <a href="https://youtu.be/1N44tL2luz8">https://youtu.be/1N44tL2luz8</a> The UI isn’t fully responsive yet and can break on some screen sizes. It works best on my setup right now, since I focused more on the system itself than the frontend. If anyone is open to taking a look at the code, I’d really appreciate any kind of feedback: <a href="https://github.com/Hernandez-Marcos/Triple-task">https://github.com/Hernandez-Marcos/Triple-task</a> If you&#39;re curious, there are more details about the project in the README. This is my first project outside of course-based ones and built without following a tutorial, mainly as a way to learn and improve, so I’d also appreciate any advice on how I could grow as a developer or better position myself for job opportunities. </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/Soggy-Market9838"> /u/Soggy-Market9838 </a> <a href="https://www.reddit.com/r/django/comments/1sk4hv9/i_built_a_realtime_browser_game_with_django_and/">[link]</a> &#32; <a href="https://www.reddit.com/r/django/comments/1sk4hv9/i_built_a_realtime_browser_game_with_django_and/">[comments]</a>

It runs 3 mini-games at the same time (math, pattern memory, and a grid where you identify the dominant color). Each one has its own timer while also sharing a global timer, so you have to manage everything under time pressure.
 There’s also a simple ranking system and player profiles.
 Here’s a short gameplay video for context:
 https://youtu.be/1N44tL2luz8
 The UI isn’t fully responsive yet and can break on some screen sizes. It works best on my setup right now, since I focused more on the system itself than the frontend.
 If anyone is open to taking a look at the code, I’d really appreciate any kind of feedback:
 https://github.com/Hernandez-Marcos/Triple-task
 If you're curious, there are more details about the project in the README.
 This is my first project outside of course-based ones and built without following a tutorial, mainly as a way to learn and improve, so I’d also appreciate any advice on how I could grow as a developer or better position myself for job opportunities.
    submitted by    /u/Soggy-Market9838  
 [link]   [comments]

I built a real-time browser game with Django and would really appreciate feedback.

<div class="md">I’m the solo developer behind a SaaS project called Invoice Parse. Currently, the entire project is built using traditional Django full-stack: Django Templates and HTML/Bootstrap. It works great, but as the application logic grows, I want to migrate the &quot;App&quot; portion (everything behind the login) to React for a more dynamic and responsive user experience. However, I want to keep my public-facing pages (Landing page, Pricing, About, etc.) strictly in Django Templates + Bootstrap. I want these pages to remain as lightweight as possible to render fast in the browser and keep SEO optimal. Additionally, I want to move towards a decoupled architecture. My goal is to have the React frontend in its own dedicated GitHub repository. This way, I can deploy new backend features (API updates) without needing to redeploy the frontend, and vice versa. I would love to hear from anyone who has navigated this transition! Specifically, I&#39;m looking for advice on: The Hybrid Approach: What is the best way to hand off the user from the Django-rendered landing pages to the decoupled React SPA upon login? Authentication: Since the public pages are Django templates, should I stick to standard Session Auth and pass the CSRF token to React, or is it better to switch strictly to JWT (like Django Rest Framework SimpleJWT) once they hit the React app? Repository Setup &amp; Deployment: What are the best practices for managing this split? (e.g., serving the React app via Vercel/Netlify while the Django API lives on Heroku/AWS, and handling CORS properly). Pitfalls: What are the &quot;gotchas&quot; or things you wish you knew before decoupling your frontend from Django? Any resources, tutorials, or personal experiences would be hugely appreciated. Thanks in advance! </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/autonomousWorld"> /u/autonomousWorld </a> <a href="https://www.reddit.com/r/django/comments/1si17zb/advice_needed_migrating_my_saas_to_a_hybrid/">[link]</a> &#32; <a href="https://www.reddit.com/r/django/comments/1si17zb/advice_needed_migrating_my_saas_to_a_hybrid/">[comments]</a>

I’m the solo developer behind a SaaS project called Invoice Parse. Currently, the entire project is built using traditional Django full-stack: Django Templates and HTML/Bootstrap.
 It works great, but as the application logic grows, I want to migrate the "App" portion (everything behind the login) to React for a more dynamic and responsive user experience.
 However, I want to keep my public-facing pages (Landing page, Pricing, About, etc.) strictly in Django Templates + Bootstrap. I want these pages to remain as lightweight as possible to render fast in the browser and keep SEO optimal.
 Additionally, I want to move towards a decoupled architecture. My goal is to have the React frontend in its own dedicated GitHub repository. This way, I can deploy new backend features (API updates) without needing to redeploy the frontend, and vice versa.
 I would love to hear from anyone who has navigated this transition! Specifically, I'm looking for advice on:
 The Hybrid Approach: What is the best way to hand off the user from the Django-rendered landing pages to the decoupled React SPA upon login?
 Authentication: Since the public pages are Django templates, should I stick to standard Session Auth and pass the CSRF token to React, or is it better to switch strictly to JWT (like Django Rest Framework SimpleJWT) once they hit the React app?
 Repository Setup & Deployment: What are the best practices for managing this split? (e.g., serving the React app via Vercel/Netlify while the Django API lives on Heroku/AWS, and handling CORS properly).
 Pitfalls: What are the "gotchas" or things you wish you knew before decoupling your frontend from Django?
 Any resources, tutorials, or personal experiences would be hugely appreciated. Thanks in advance!
    submitted by    /u/autonomousWorld  
 [link]   [comments]

Advice needed: Migrating my SaaS to a hybrid architecture (Django/Bootstrap for public pages, React for the authenticated app)

<div class="md">We have developed an open source django and celery based web app for computation of spatial overlap between contours as well as for computation of STAPLE contours for use in radiation oncology. Repo here: <a href="https://github.com/CHAVI-India/COMET">https://github.com/CHAVI-India/COMET</a> </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/indianradonc"> /u/indianradonc </a> <a href="https://www.reddit.com/r/django/comments/1sff69j/comet_contour_metrics/">[link]</a> &#32; <a href="https://www.reddit.com/r/django/comments/1sff69j/comet_contour_metrics/">[comments]</a>

We have developed an open source django and celery based web app for computation of spatial overlap between contours as well as for computation of STAPLE contours for use in radiation oncology. Repo here: https://github.com/CHAVI-India/COMET
    submitted by    /u/indianradonc  
 [link]   [comments]

COMET (COntour METrics)

<div class="md">Hello, I&#39;ve been working on django-email-learning, a Django app that lets you build learning platforms where course content is delivered entirely via email — lessons, quizzes, schedules, the whole thing — no need for learners to log into a portal. The inspiration was an old service called Darsnameh that shut down in 2017. The idea is especially useful for learners in regions with poor connectivity or restrictive internet access. Quick overview: <ul> <li>Create courses, lessons and quizzes through an admin/platform UI</li> <li>Automated scheduled delivery via management commands (cron/cloud scheduler)</li> <li>Progress tracking and completion certificates</li> <li>React frontend components</li> <li>IMAP integration</li> </ul> It&#39;s currently in beta version and available on PyPI. Docs at django-email-learning.readthedocs.io. I also built <a href="http://InboxAcademy.io">InboxAcademy.io</a> on top of it as a live demo — it&#39;s running a course that walks Django devs through setting the whole thing up. Would love feedback from this community especially on the architecture and any rough edges. Happy to answer questions! [<a href="https://github.com/AvaCodeSolutions/django-email-learning">GitHub link</a>] | [<a href="https://django-email-learning.readthedocs.io/">Docs</a>] | [<a href="https://inboxacademy.io/organizations/1/courses/django-email-learning/">InboxAcademy.io</a>] <a href="https://preview.redd.it/cnb3zxlg8fug1.png?width=512&amp;format=png&amp;auto=webp&amp;s=1ae6fecdd3af07008858df81f27545034fdd0d6c">https://preview.redd.it/cnb3zxlg8fug1.png?width=512&amp;format=png&amp;auto=webp&amp;s=1ae6fecdd3af07008858df81f27545034fdd0d6c</a> </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/Similar-Storm4432"> /u/Similar-Storm4432 </a> <a href="https://www.reddit.com/r/django/comments/1shxxdy/i_built_an_opensource_django_app_for_emailbased/">[link]</a> &#32; <a href="https://www.reddit.com/r/django/comments/1shxxdy/i_built_an_opensource_django_app_for_emailbased/">[comments]</a>

Hello,
 I've been working on django-email-learning, a Django app that lets you build learning platforms where course content is delivered entirely via email — lessons, quizzes, schedules, the whole thing — no need for learners to log into a portal.
 The inspiration was an old service called Darsnameh that shut down in 2017. The idea is especially useful for learners in regions with poor connectivity or restrictive internet access.
 Quick overview:
  
Create courses, lessons and quizzes through an admin/platform UI
 Automated scheduled delivery via management commands (cron/cloud scheduler)
 Progress tracking and completion certificates
 React frontend components
 IMAP integration
  
It's currently in beta version and available on PyPI. Docs at django-email-learning.readthedocs.io.
 I also built InboxAcademy.io on top of it as a live demo — it's running a course that walks Django devs through setting the whole thing up.
 Would love feedback from this community especially on the architecture and any rough edges. Happy to answer questions!
 [GitHub link] | [Docs] | [InboxAcademy.io]
 https://preview.redd.it/cnb3zxlg8fug1.png?width=512&format=png&auto=webp&s=1ae6fecdd3af07008858df81f27545034fdd0d6c
    submitted by    /u/Similar-Storm4432  
 [link]   [comments]

I built an open-source Django app for email-based learning platforms – looking for feedback

<table> <tr><td> <a href="https://www.reddit.com/r/flask/comments/1sh52zo/pow_shield_test_2_localhost_in_the_front/"> <img src="https://external-preview.redd.it/bGh0cjF0Zm92OHVnMUToZ1IBV74wBwGjMmtUi8nbYz4QfHj5U_sNW4wMIYGd.png?width=640&amp;crop=smart&amp;auto=webp&amp;s=0cd972dddddc1c02f472ad2f30222177928224e5" alt="pow shield test 2 (localhost in the front, neocities in the back)" title="pow shield test 2 (localhost in the front, neocities in the back)" /> </a> </td><td> &#32; submitted by &#32; <a href="https://www.reddit.com/user/WW92030"> /u/WW92030 </a> <a href="https://v.redd.it/w659mefov8ug1">[link]</a> &#32; <a href="https://www.reddit.com/r/flask/comments/1sh52zo/pow_shield_test_2_localhost_in_the_front/">[comments]</a> </td></tr></table>

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

pow shield test 2 (localhost in the front, neocities in the back)

<div class="md">My company (JigsawML) builds a scanner that reads a software repo and outputs architectural diagrams. I persuaded them to provide a version that will read the Flask repo with a single button (no signups). If you add &quot;/open-source-projects&quot; to the company URL, it will take you directly to the scanner. I put this in the link section. I&#39;ve left a few screenshots so that you can get a sense of what it does. In the next few weeks, diffs and deeper granularity will be added. Oh yes, you can ask questions about the architecture using an &quot;Ask AI&quot; capability. </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/CraterLakeGodzilla"> /u/CraterLakeGodzilla </a> <a href="https://www.reddit.com/r/flask/comments/1sgxauv/queryable_sw_architecture_diagram_for_flask_repo/">[link]</a> &#32; <a href="https://www.reddit.com/r/flask/comments/1sgxauv/queryable_sw_architecture_diagram_for_flask_repo/">[comments]</a>

My company (JigsawML) builds a scanner that reads a software repo and outputs architectural diagrams. I persuaded them to provide a version that will read the Flask repo with a single button (no signups). 
 If you add "/open-source-projects" to the company URL, it will take you directly to the scanner. I put this in the link section.
 I've left a few screenshots so that you can get a sense of what it does.
 In the next few weeks, diffs and deeper granularity will be added. Oh yes, you can ask questions about the architecture using an "Ask AI" capability.
    submitted by    /u/CraterLakeGodzilla  
 [link]   [comments]

Hello, Python

Python Jobs 💼