<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">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">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.

&#32; submitted by &#32; <a href="https://www.reddit.com/user/dwaxe"> /u/dwaxe </a> <a href="https://www.djangoproject.com/weblog/2026/apr/15/contributor-covenant-adoption/">[link]</a> &#32; <a href="https://www.reddit.com/r/django/comments/1smiuub/django_has_adopted_contributor_covenant_3/">[comments]</a>

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

Django Has Adopted Contributor Covenant 3

<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">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?

&#32; submitted by &#32; <a href="https://www.reddit.com/user/dwaxe"> /u/dwaxe </a> <a href="https://www.djangoproject.com/weblog/2026/apr/16/pycharm-django-annual-fundraiser/">[link]</a> &#32; <a href="https://www.reddit.com/r/django/comments/1snbk50/pycharm_django_annual_fundraiser/">[comments]</a>

PyCharm & Django annual fundraiser

<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">I don’t know if it’s just me, but every time I tried to build something with people online it went the same way. People are interested. You create a group. Everyone disappears after a couple of days. So a couple of weeks ago I started working on something to fix that. It’s basically a place where you can: join real projects (not just ideas) form small teams based on stack and actually work together (tasks, chat, code, etc.) Right now we’re around 150 users. Only a small part is actually active (\~20), but those teams are really building stuff. So now I’m trying to understand what makes the difference. If you’ve ever tried building with strangers: what made it work (or fail)? If you’re curious: <a href="https://www.codekhub.it/">https://www.codekhub.it/</a> </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/Weary-Wrangler6798"> /u/Weary-Wrangler6798 </a> <a href="https://www.reddit.com/r/django/comments/1smyw1g/i_git_tired_of_lets_build_something_together/">[link]</a> &#32; <a href="https://www.reddit.com/r/django/comments/1smyw1g/i_git_tired_of_lets_build_something_together/">[comments]</a>

I don’t know if it’s just me, but every time I tried to build something with people online it went the same way.
 People are interested. You create a group. Everyone disappears after a couple of days.
 So a couple of weeks ago I started working on something to fix that.
 It’s basically a place where you can:
 join real projects (not just ideas)
 form small teams based on stack
 and actually work together (tasks, chat, code, etc.)
 Right now we’re around 150 users.
 Only a small part is actually active (\~20), but those teams are really building stuff.
 So now I’m trying to understand what makes the difference.
 If you’ve ever tried building with strangers: what made it work (or fail)?
 If you’re curious:
 https://www.codekhub.it/
    submitted by    /u/Weary-Wrangler6798  
 [link]   [comments]

I git tired of “let’s build something together” going nowhere, so I tried this

<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

&#32; submitted by &#32; <a href="https://www.reddit.com/user/thedryan"> /u/thedryan </a> <a href="https://www.djangoproject.com/weblog/2026/apr/15/contributor-covenant-adoption/">[link]</a> &#32; <a href="https://www.reddit.com/r/django/comments/1smis7m/django_project_adopts_contributor_covenant_3/">[comments]</a>

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

Django Project Adopts Contributor Covenant 3

<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 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

&#32; submitted by &#32; <a href="https://www.reddit.com/user/meagenvoss"> /u/meagenvoss </a> <a href="https://wagtail.org/agency-survey">[link]</a> &#32; <a href="https://www.reddit.com/r/django/comments/1sma06a/please_help_us_find_agencies_working_with_wagtail/">[comments]</a>

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

Please help us find agencies working with Wagtail CMS

<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">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">Hi everyone, I want to re-introduce my package <a href="https://github.com/huynguyengl99/chanx">ChanX</a>, an extension for Django Channels that makes WebSocket and realtime app development and maintenance much easier. As a developer who has been heavily working on realtime applications (group messaging, realtime voice handling with Deepgram integration, AI assistant chat), I always wished there was a package that could extend Django Channels to provide: <ul> <li>Easier WebSocket (chat/data) handling without if-else hell</li> <li>Type safety that works with mypy and pyright to catch errors before writing tests or going live in production</li> <li>Auto-documentation with AsyncAPI-compatible docs autogenerated from code, similar to how drf-spectacular generates OpenAPI from DRF serializers</li> <li>Testing utilities that make testing flows predictable and correct</li> <li>Logging helpers, like django-structlog, to trace what was received and what was sent in a message handling flow</li> <li>Even a command line tool to generate code from the generated docs (e.g. for other microservices to use)</li> </ul> And if you have ever used Django Channels to handle WebSocket/realtime messaging, I think you have likely run into these same problems: <ul> <li>Inconsistent implementations between consumers: some use if-else, some use match-case, resulting in messy logic</li> <li>Painful code reviews, since you cannot tell when something will respond or what it accepts without carefully reading through the full code end to end</li> <li>Slow onboarding and slow integration with other teams (e.g. frontend) due to the lack of any documentation or API contract (AsyncAPI docs are very helpful here)</li> <li>Testing that is hard and unpredictable, since the default testing in Django Channels is based on timing or the first response, but sometimes we need more</li> <li>Difficulty tracing how and where the code runs</li> </ul> So I built ChanX based on what I have done, faced, and wished I had for my last project. I am using it now and I love it. I built it with careful design and active maintenance, so I hope you find it useful and never have to face these problems again. Some use cases where ChanX works well: <ul> <li>Realtime messaging (one-on-one or group chat with broadcasting and notifications)</li> <li>Realtime voice assistants (e.g. Deepgram, OpenAI) or chat assistants with streaming responses</li> <li>Any scenario that involves group messaging, broadcasting, or push notifications over WebSocket</li> </ul> Also, some people have suggested using SSE rather than WebSocket when working with Django. I think in simple cases that would be fine, but I prefer the WebSocket/Channels approach because we get proper async handling and proper documentation (AsyncAPI). Here are the links for my package: <ul> <li>Github: <a href="https://github.com/huynguyengl99/chanx">https://github.com/huynguyengl99/chanx</a></li> <li>PyPI: <a href="https://pypi.org/project/chanx">https://pypi.org/project/chanx</a></li> <li>Documentation: <a href="https://chanx.readthedocs.io/">https://chanx.readthedocs.io/</a></li> <li>Tutorial for newcomers: <a href="https://chanx.readthedocs.io/en/latest/tutorial-django/prerequisites.html">https://chanx.readthedocs.io/en/latest/tutorial-django/prerequisites.html</a></li> </ul> Hope you all find it useful. </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/huygl99"> /u/huygl99 </a> <a href="https://www.reddit.com/r/django/comments/1so5ggu/chanx_an_extension_library_for_django_channels/">[link]</a> &#32; <a href="https://www.reddit.com/r/django/comments/1so5ggu/chanx_an_extension_library_for_django_channels/">[comments]</a>

Hi everyone, I want to re-introduce my package ChanX, an extension for Django Channels that makes WebSocket and realtime app development and maintenance much easier.
 As a developer who has been heavily working on realtime applications (group messaging, realtime voice handling with Deepgram integration, AI assistant chat), I always wished there was a package that could extend Django Channels to provide:
  
Easier WebSocket (chat/data) handling without if-else hell
 Type safety that works with mypy and pyright to catch errors before writing tests or going live in production
 Auto-documentation with AsyncAPI-compatible docs autogenerated from code, similar to how drf-spectacular generates OpenAPI from DRF serializers
 Testing utilities that make testing flows predictable and correct
 Logging helpers, like django-structlog, to trace what was received and what was sent in a message handling flow
 Even a command line tool to generate code from the generated docs (e.g. for other microservices to use)
  
And if you have ever used Django Channels to handle WebSocket/realtime messaging, I think you have likely run into these same problems:
  
Inconsistent implementations between consumers: some use if-else, some use match-case, resulting in messy logic
 Painful code reviews, since you cannot tell when something will respond or what it accepts without carefully reading through the full code end to end
 Slow onboarding and slow integration with other teams (e.g. frontend) due to the lack of any documentation or API contract (AsyncAPI docs are very helpful here)
 Testing that is hard and unpredictable, since the default testing in Django Channels is based on timing or the first response, but sometimes we need more
 Difficulty tracing how and where the code runs
  
So I built ChanX based on what I have done, faced, and wished I had for my last project. I am using it now and I love it. I built it with careful design and active maintenance, so I hope you find it useful and never have to face these problems again.
 Some use cases where ChanX works well:
  
Realtime messaging (one-on-one or group chat with broadcasting and notifications)
 Realtime voice assistants (e.g. Deepgram, OpenAI) or chat assistants with streaming responses
 Any scenario that involves group messaging, broadcasting, or push notifications over WebSocket
  
Also, some people have suggested using SSE rather than WebSocket when working with Django. I think in simple cases that would be fine, but I prefer the WebSocket/Channels approach because we get proper async handling and proper documentation (AsyncAPI).
 Here are the links for my package:
  
Github: https://github.com/huynguyengl99/chanx
 PyPI: https://pypi.org/project/chanx
 Documentation: https://chanx.readthedocs.io/
 Tutorial for newcomers: https://chanx.readthedocs.io/en/latest/tutorial-django/prerequisites.html
  
Hope you all find it useful.
    submitted by    /u/huygl99  
 [link]   [comments]

ChanX: An extension library for Django Channels that makes building realtime applications a breeze

&#32; submitted by &#32; <a href="https://www.reddit.com/user/dwaxe"> /u/dwaxe </a> <a href="https://www.djangoproject.com/weblog/2026/apr/16/new-technical-governance-request-for-community-fee/">[link]</a> &#32; <a href="https://www.reddit.com/r/django/comments/1snet4r/new_technical_governance_request_for_community/">[comments]</a>

New Technical Governance - request for community feedback

<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">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. Edit: I should&#39;ve specify this first, but we are all students in a semi-internship (we work for a real client but it&#39;s still seen as a normal university course, no payment). This is most of our first experience with Django and likely most of our first time doing real Software Engineering. </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.
 Edit: I should've specify this first, but we are all students in a semi-internship (we work for a real client but it's still seen as a normal university course, no payment). This is most of our first experience with Django and likely most of our first time doing real Software Engineering.
    submitted by    /u/AyrtonHS  
 [link]   [comments]

Migrations in .gitignore during development

<div class="md">I just shipped ArchUnitPython, a library that lets you enforce architectural rules in Python projects through automated tests. The problem it solves: as codebases grow, architecture erodes. Someone imports the database layer from the presentation layer, circular dependencies creep in, naming conventions drift. Code review catches some of it, but not all, and definitely not consistently. This problem has always existed but is more important than ever in Claude Code, Codex times. LLMs break architectural rules all the time. So I built a library where you define your architecture rules as tests. Two quick examples: ```python <h1>No circular dependencies in services</h1> rule = project_files(&quot;src/&quot;).in_folder(&quot;/services/&quot;).should().have_no_cycles() assert_passes(rule) ``` ```python <h1>Presentation layer must not depend on database layer</h1> rule = project_files(&quot;src/&quot;) .in_folder(&quot;/presentation/&quot;) .should_not() .depend_on_files() .in_folder(&quot;/database/&quot;) assert_passes(rule) ``` This will run in pytest, unittest, or whatever you use, and therefore be automatically in your CI/CD. If a commit violates the architecture rules your team has decided, the CI will fail. Hint: this is exactly what the famous ArchUnit Java library does, just for Python - I took inspiration for the name is of course. Let me quickly address why this over linters or generic code analysis? Linters catch style issues. This catches structural violations — wrong dependency directions, layering breaches, naming convention drift. It&#39;s the difference between &quot;this line looks wrong&quot; and &quot;this module shouldn&#39;t talk to that module.&quot; Some key features: <ul> <li>Dependency direction enforcement &amp; circular dependency detection</li> <li>Naming convention checks (glob + regex)</li> <li>Code metrics: LCOM cohesion, abstractness, instability, distance from main sequence</li> <li>PlantUML diagram validation — ensure code matches your architecture diagrams</li> <li>Custom rules &amp; metrics</li> <li>Zero runtime dependencies, uses only Python&#39;s ast module</li> <li>Python 3.10+</li> </ul> Very curious what you think! <a href="https://github.com/LukasNiessen/ArchUnitPython">https://github.com/LukasNiessen/ArchUnitPython</a> </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/trolleid"> /u/trolleid </a> <a href="https://github.com/LukasNiessen/ArchUnitPython">[link]</a> &#32; <a href="https://www.reddit.com/r/django/comments/1sn4sfr/i_built_archunit_for_python_enforce_architecture/">[comments]</a>

I just shipped ArchUnitPython, a library that lets you enforce architectural rules in Python projects through automated tests.
 The problem it solves: as codebases grow, architecture erodes. Someone imports the database layer from the presentation layer, circular dependencies creep in, naming conventions drift. Code review catches some of it, but not all, and definitely not consistently.
 This problem has always existed but is more important than ever in Claude Code, Codex times. LLMs break architectural rules all the time.
 So I built a library where you define your architecture rules as tests. Two quick examples:
 ```python
 No circular dependencies in services
 rule = project_files("src/").in_folder("/services/").should().have_no_cycles() assert_passes(rule) ```
 ```python
 Presentation layer must not depend on database layer
 rule = project_files("src/") .in_folder("/presentation/") .should_not() .depend_on_files() .in_folder("/database/") assert_passes(rule) ```
 This will run in pytest, unittest, or whatever you use, and therefore be automatically in your CI/CD. If a commit violates the architecture rules your team has decided, the CI will fail.
 Hint: this is exactly what the famous ArchUnit Java library does, just for Python - I took inspiration for the name is of course.
 Let me quickly address why this over linters or generic code analysis?
 Linters catch style issues. This catches structural violations — wrong dependency directions, layering breaches, naming convention drift. It's the difference between "this line looks wrong" and "this module shouldn't talk to that module."
 Some key features:
  
Dependency direction enforcement & circular dependency detection
 Naming convention checks (glob + regex)
 Code metrics: LCOM cohesion, abstractness, instability, distance from main sequence
 PlantUML diagram validation — ensure code matches your architecture diagrams
 Custom rules & metrics
 Zero runtime dependencies, uses only Python's ast module
 Python 3.10+
  
Very curious what you think! https://github.com/LukasNiessen/ArchUnitPython
    submitted by    /u/trolleid  
 [link]   [comments]

I built ArchUnit for Python: enforce architecture rules as unit tests.

<div class="md">Hi everyone, I’ve been working on a project called pgproto and wanted to share it with the Django community to see if I’m headed in the right direction. In a lot of my projects, I use Protobuf for speed, but when it comes to the database, I usually ended up either storing them as blobs (which makes them unqueryable) or converting them to JSONB (which feels like it defeats the purpose of using a compact binary format). I wrote this C extension to allow Postgres to &quot;understand&quot; the <code>.proto</code> schema. It lets you: <ul> <li>Keep data in its compact binary form (about 60% smaller than JSONB in my tests).</li> <li>Query nested fields directly in SQL using operators similar to Django’s <code>JSONField</code> lookups (<code>#&gt;</code> and <code>-&gt;</code>).</li> <li>Index those fields so you don&#39;t lose lookup performance.</li> </ul> I’m still refining it, but I’m curious—does this solve a pain point for anyone else here? Or do most of you just stick with JSONB and accept the storage overhead? GitHub:<a href="https://github.com/Apaezmx/pgproto">https://github.com/Apaezmx/pgproto</a> I’d really appreciate any feedback on the design or features! </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/ComfortableSpend6111"> /u/ComfortableSpend6111 </a> <a href="https://www.reddit.com/r/django/comments/1slf7le/i_wrote_a_postgres_extension_to_handle_protobufs/">[link]</a> &#32; <a href="https://www.reddit.com/r/django/comments/1slf7le/i_wrote_a_postgres_extension_to_handle_protobufs/">[comments]</a>

Hi everyone,
 I’ve been working on a project called pgproto and wanted to share it with the Django community to see if I’m headed in the right direction.
 In a lot of my projects, I use Protobuf for speed, but when it comes to the database, I usually ended up either storing them as blobs (which makes them unqueryable) or converting them to JSONB (which feels like it defeats the purpose of using a compact binary format).
 I wrote this C extension to allow Postgres to "understand" the .proto schema. It lets you:
  
Keep data in its compact binary form (about 60% smaller than JSONB in my tests).
 Query nested fields directly in SQL using operators similar to Django’s JSONField lookups (#> and ->).
 Index those fields so you don't lose lookup performance.
  
I’m still refining it, but I’m curious—does this solve a pain point for anyone else here? Or do most of you just stick with JSONB and accept the storage overhead?
 GitHub:https://github.com/Apaezmx/pgproto
 I’d really appreciate any feedback on the design or features!
    submitted by    /u/ComfortableSpend6111  
 [link]   [comments]

I wrote a Postgres extension to handle Protobufs natively. Would love to know if this is useful for Django/gRPC setups.

<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">Two years ago, my friend and I launched a football prediction pool for the Euros with a twist. In a lot of pools, you can keep predicting boring scores like 1-0 and do surprisingly well. So we built our own system to make it more interesting: correct predictions would score points based on how unlikely they were. A predictable result would be worth less, while correctly calling a surprise scoreline would earn more. We used team ELO ratings and statistical models to estimate score probabilities, then based the scoring on those odds. At first it was just for our own friend group, but when we made it public for the Euros 2024, it actually took off more than we expected. We ended up with around 2,000 users, which felt huge for a small side project built mainly for fun. That momentum made us think we were onto something. So this year we went further: we relaunched under a new name, <a href="http://Goalguessers.com">Goalguessers.com</a>, and even built both Android and iPhone apps to make it feel like a proper product instead of a one-off tournament tool. But now the opposite is happening. Two years ago 2,000 people joined. This time, almost nobody is. Is the internet so flooded with AI products now that nobody notices handcrafted apps? </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/Pacemates"> /u/Pacemates </a> <a href="https://www.reddit.com/r/django/comments/1snt9al/from_2000_users_to_almost_none_are_handcrafted/">[link]</a> &#32; <a href="https://www.reddit.com/r/django/comments/1snt9al/from_2000_users_to_almost_none_are_handcrafted/">[comments]</a>

Two years ago, my friend and I launched a football prediction pool for the Euros with a twist. In a lot of pools, you can keep predicting boring scores like 1-0 and do surprisingly well. 
 So we built our own system to make it more interesting: correct predictions would score points based on how unlikely they were. A predictable result would be worth less, while correctly calling a surprise scoreline would earn more. We used team ELO ratings and statistical models to estimate score probabilities, then based the scoring on those odds.
 At first it was just for our own friend group, but when we made it public for the Euros 2024, it actually took off more than we expected. We ended up with around 2,000 users, which felt huge for a small side project built mainly for fun.
 That momentum made us think we were onto something. So this year we went further: we relaunched under a new name, Goalguessers.com, and even built both Android and iPhone apps to make it feel like a proper product instead of a one-off tournament tool.
 But now the opposite is happening. Two years ago 2,000 people joined. This time, almost nobody is. Is the internet so flooded with AI products now that nobody notices handcrafted apps?
    submitted by    /u/Pacemates  
 [link]   [comments]

From 2000 users to almost none: are handcrafted apps getting buried?

<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

<table> <tr><td> <a href="https://www.reddit.com/r/FastAPI/comments/1sn4qdw/i_built_archunit_for_python_enforce_architecture/"> <img src="https://external-preview.redd.it/QEMbFJik1ifoXLHmdkjeFhYNxvKZbC_flyGhEeS-RUY.png?width=640&amp;crop=smart&amp;auto=webp&amp;s=02b5a571796257d8389a6e1300584c7199cc441e" alt="I built ArchUnit for Python: enforce architecture rules as unit tests." title="I built ArchUnit for Python: enforce architecture rules as unit tests." /> </a> </td><td> <div class="md">I just shipped ArchUnitPython, a library that lets you enforce architectural rules in Python projects through automated tests. The problem it solves: as codebases grow, architecture erodes. Someone imports the database layer from the presentation layer, circular dependencies creep in, naming conventions drift. Code review catches some of it, but not all, and definitely not consistently. This problem has always existed but is more important than ever in Claude Code, Codex times. LLMs break architectural rules all the time. So I built a library where you define your architecture rules as tests. Two quick examples: ```python <h1>No circular dependencies in services</h1> rule = project_files(&quot;src/&quot;).in_folder(&quot;/services/&quot;).should().have_no_cycles() assert_passes(rule) ``` ```python <h1>Presentation layer must not depend on database layer</h1> rule = project_files(&quot;src/&quot;) .in_folder(&quot;/presentation/&quot;) .should_not() .depend_on_files() .in_folder(&quot;/database/&quot;) assert_passes(rule) ``` This will run in pytest, unittest, or whatever you use, and therefore be automatically in your CI/CD. If a commit violates the architecture rules your team has decided, the CI will fail. Hint: this is exactly what the famous ArchUnit Java library does, just for Python - I took inspiration for the name is of course. Let me quickly address why this over linters or generic code analysis? Linters catch style issues. This catches structural violations — wrong dependency directions, layering breaches, naming convention drift. It&#39;s the difference between &quot;this line looks wrong&quot; and &quot;this module shouldn&#39;t talk to that module.&quot; Some key features: <ul> <li>Dependency direction enforcement &amp; circular dependency detection</li> <li>Naming convention checks (glob + regex)</li> <li>Code metrics: LCOM cohesion, abstractness, instability, distance from main sequence</li> <li>PlantUML diagram validation — ensure code matches your architecture diagrams</li> <li>Custom rules &amp; metrics</li> <li>Zero runtime dependencies, uses only Python&#39;s ast module</li> <li>Python 3.10+</li> </ul> Very curious what you think! <a href="https://github.com/LukasNiessen/ArchUnitPython">https://github.com/LukasNiessen/ArchUnitPython</a> </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/trolleid"> /u/trolleid </a> <a href="https://github.com/LukasNiessen/ArchUnitPython">[link]</a> &#32; <a href="https://www.reddit.com/r/FastAPI/comments/1sn4qdw/i_built_archunit_for_python_enforce_architecture/">[comments]</a> </td></tr></table>

<div class="md">I don’t know if it’s just me, but every time I tried to build something with people online it went the same way. People are interested. You create a group. Everyone disappears after a couple of days. So a couple of weeks ago I started working on something to fix that. It’s basically a place where you can: join real projects (not just ideas) form small teams based on stack and actually work together (tasks, chat, code, etc.) Right now we’re around 150 users. Only a small part is actually active (~20), but those teams are really building stuff. So now I’m trying to understand what makes the difference. If you’ve ever tried building with strangers: what made it work (or fail)? If you’re curious: <a href="https://www.codekhub.it/%E2%81%A0%EF%BF%BD">https://www.codekhub.it/⁠�</a> </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/Weary-Wrangler6798"> /u/Weary-Wrangler6798 </a> <a href="https://www.reddit.com/r/FastAPI/comments/1sm0kg2/i_got_tired_of_lets_build_something_together/">[link]</a> &#32; <a href="https://www.reddit.com/r/FastAPI/comments/1sm0kg2/i_got_tired_of_lets_build_something_together/">[comments]</a>

I don’t know if it’s just me, but every time I tried to build something with people online it went the same way.
 People are interested.
 You create a group.
 Everyone disappears after a couple of days.
 So a couple of weeks ago I started working on something to fix that.
 It’s basically a place where you can:
 join real projects (not just ideas)
 form small teams based on stack
 and actually work together (tasks, chat, code, etc.)
 Right now we’re around 150 users.
 Only a small part is actually active (~20), but those teams are really building stuff.
 So now I’m trying to understand what makes the difference.
 If you’ve ever tried building with strangers: what made it work (or fail)?
 If you’re curious:
 https://www.codekhub.it/⁠�
    submitted by    /u/Weary-Wrangler6798  
 [link]   [comments]

I got tired of “let’s build something together” going nowhere, so I tried this

<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)

<table> <tr><td> <a href="https://www.reddit.com/r/FastAPI/comments/1so6jau/fastchannels_and_chanx_the_missing_toolkit_for/"> <img src="https://external-preview.redd.it/II551CTOz56xvVYNJV5q5GXqVsHgRVFlPpRRCKp3upQ.png?width=140&amp;height=70&amp;auto=webp&amp;s=fe56228c47b69cd6cbb5f81dd87c059a9e78512c" alt="FastChannels and ChanX: The missing toolkit for WebSocket handling in FastAPI" title="FastChannels and ChanX: The missing toolkit for WebSocket handling in FastAPI" /> </a> </td><td> <div class="md">Hi everyone, I want to share with you both of my packages, which are mainly for improving FastAPI (and any ASGI-compatible library) when it comes to WebSocket handling. First, FastAPI&#39;s WebSocket handling is fairly simple with @app.websocket where you define the flow and run the loop (while True), but this can lead to some problems: <ul> <li>Harder to debug and separate code</li> <li>No way to broadcast messages. FastAPI&#39;s official guide uses a ConnectionManager as a simple class, but it is in-memory, fragile, and hard to scale</li> <li>FastAPI also mentions: &quot;If you need something easy to integrate with FastAPI but that is more robust, supported by Redis, PostgreSQL or others, check encode/broadcaster.&quot; However, broadcaster is no longer maintained as &quot;This repository was archived by the owner on Aug 19, 2025. It is now read-only.&quot; (unfortunate)</li> <li>No real way to send messages from another thread, a background job, or even an API endpoint without resorting to workarounds</li> </ul> Based on that, and with the knowledge I gained from Django Channels, I ported the Django Channels library to be fully FastAPI-compatible. The result is <a href="https://github.com/huynguyengl99/fast-channels">FastChannels</a>, which solves exactly the problems above. On top of that, when working with WebSocket (in both Django and FastAPI), my team and I usually face these problems: <ul> <li>Manual if-else routing chains when receiving a WebSocket message</li> <li>Manual validation of the messages we receive</li> <li>Runtime type surprises</li> <li>No source of truth for documentation (almost never seen, even though we have the AsyncAPI standard now)</li> <li>Testing that is painfully hard</li> <li>Painful code reviews and onboarding, since we need to scroll and read a lot to understand what messages are accepted, what the implementation does, and what gets returned</li> <li>No logging utility or standard like structlog for request and response tracing</li> </ul> Due to those problems, I created <a href="https://github.com/huynguyengl99/chanx">ChanX</a> as a library that improves the way we build WebSocket handling. Now, thanks to ChanX, we get: <ul> <li>No more endless if-else logic or 200-line functions that just route to the correct message handler. We simply define messages with the correct type, and thanks to Pydantic&#39;s type discriminator, they are automatically routed to the correct handler</li> <li>No more manual message validation, as Pydantic is the standard for defining both incoming and outgoing messages</li> <li>Type hints by default, with mypy and pyright support</li> <li>A testing framework included to make testing easier and more predictable</li> <li>And notably, auto-generated AsyncAPI documentation based on the code you define, similar to how FastAPI auto-generates OpenAPI docs from your code</li> <li>A CLI helper to generate code from AsyncAPI docs as well</li> </ul> So, here is how it looks <a href="https://preview.redd.it/3v9rtltg5svg1.png?width=1348&amp;format=png&amp;auto=webp&amp;s=c1dfecbbd58ae7040a3e58f8a85aeb73378c1c08">https://preview.redd.it/3v9rtltg5svg1.png?width=1348&amp;format=png&amp;auto=webp&amp;s=c1dfecbbd58ae7040a3e58f8a85aeb73378c1c08</a> I built ChanX based on what I have done, faced, and wished I had for my last project. I am using it now and I love it. I built it with careful design and active maintenance, so I hope you find it useful and never have to face these problems again. Some use cases where these work well: <ul> <li>Realtime messaging (one-on-one or group chat with broadcasting and notifications)</li> <li>Realtime voice assistants (e.g. Deepgram, OpenAI) or chat assistants with streaming responses</li> <li>Any scenario that involves group messaging, broadcasting, or push notifications over WebSocket</li> </ul> Here are the links related to FastChannels: <ul> <li>Github: <a href="https://github.com/huynguyengl99/fast-channels">https://github.com/huynguyengl99/fast-channels</a></li> <li>PyPI: <a href="https://pypi.org/project/fast-channels/">https://pypi.org/project/fast-channels/</a></li> <li>Documentation: <a href="https://fast-channels.readthedocs.io/en/latest/">https://fast-channels.readthedocs.io/en/latest/</a></li> <li>Tutorial for FastChannels: <a href="https://fast-channels.readthedocs.io/en/latest/tutorial/index.html">https://fast-channels.readthedocs.io/en/latest/tutorial/index.html</a></li> </ul> Here are the links related to ChanX: <ul> <li>Github: <a href="https://github.com/huynguyengl99/chanx">https://github.com/huynguyengl99/chanx</a></li> <li>PyPI: <a href="https://pypi.org/project/chanx">https://pypi.org/project/chanx</a></li> <li>Documentation: <a href="https://chanx.readthedocs.io/">https://chanx.readthedocs.io/</a></li> <li>Tutorial for newcomers: <a href="https://chanx.readthedocs.io/en/latest/tutorial-fastapi/prerequisites.html">https://chanx.readthedocs.io/en/latest/tutorial-fastapi/prerequisites.html</a></li> </ul> Hope you all find it useful. </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/huygl99"> /u/huygl99 </a> <a href="https://www.reddit.com/r/FastAPI/comments/1so6jau/fastchannels_and_chanx_the_missing_toolkit_for/">[link]</a> &#32; <a href="https://www.reddit.com/r/FastAPI/comments/1so6jau/fastchannels_and_chanx_the_missing_toolkit_for/">[comments]</a> </td></tr></table>

Hi everyone, I want to share with you both of my packages, which are mainly for improving FastAPI (and any ASGI-compatible library) when it comes to WebSocket handling.
 First, FastAPI's WebSocket handling is fairly simple with @app.websocket where you define the flow and run the loop (while True), but this can lead to some problems:
  
Harder to debug and separate code
 No way to broadcast messages. FastAPI's official guide uses a ConnectionManager as a simple class, but it is in-memory, fragile, and hard to scale
 FastAPI also mentions: "If you need something easy to integrate with FastAPI but that is more robust, supported by Redis, PostgreSQL or others, check encode/broadcaster." However, broadcaster is no longer maintained as "This repository was archived by the owner on Aug 19, 2025. It is now read-only." (unfortunate)
 No real way to send messages from another thread, a background job, or even an API endpoint without resorting to workarounds
  
Based on that, and with the knowledge I gained from Django Channels, I ported the Django Channels library to be fully FastAPI-compatible. The result is FastChannels, which solves exactly the problems above.
 On top of that, when working with WebSocket (in both Django and FastAPI), my team and I usually face these problems:
  
Manual if-else routing chains when receiving a WebSocket message
 Manual validation of the messages we receive
 Runtime type surprises
 No source of truth for documentation (almost never seen, even though we have the AsyncAPI standard now)
 Testing that is painfully hard
 Painful code reviews and onboarding, since we need to scroll and read a lot to understand what messages are accepted, what the implementation does, and what gets returned
 No logging utility or standard like structlog for request and response tracing
  
Due to those problems, I created ChanX as a library that improves the way we build WebSocket handling. Now, thanks to ChanX, we get:
  
No more endless if-else logic or 200-line functions that just route to the correct message handler. We simply define messages with the correct type, and thanks to Pydantic's type discriminator, they are automatically routed to the correct handler
 No more manual message validation, as Pydantic is the standard for defining both incoming and outgoing messages
 Type hints by default, with mypy and pyright support
 A testing framework included to make testing easier and more predictable
 And notably, auto-generated AsyncAPI documentation based on the code you define, similar to how FastAPI auto-generates OpenAPI docs from your code
 A CLI helper to generate code from AsyncAPI docs as well
  
So, here is how it looks
 https://preview.redd.it/3v9rtltg5svg1.png?width=1348&format=png&auto=webp&s=c1dfecbbd58ae7040a3e58f8a85aeb73378c1c08
 I built ChanX based on what I have done, faced, and wished I had for my last project. I am using it now and I love it. I built it with careful design and active maintenance, so I hope you find it useful and never have to face these problems again.
 Some use cases where these work well:
  
Realtime messaging (one-on-one or group chat with broadcasting and notifications)
 Realtime voice assistants (e.g. Deepgram, OpenAI) or chat assistants with streaming responses
 Any scenario that involves group messaging, broadcasting, or push notifications over WebSocket
  
Here are the links related to FastChannels:
  
Github: https://github.com/huynguyengl99/fast-channels
 PyPI: https://pypi.org/project/fast-channels/
 Documentation: https://fast-channels.readthedocs.io/en/latest/
 Tutorial for FastChannels: https://fast-channels.readthedocs.io/en/latest/tutorial/index.html
  
Here are the links related to ChanX:
  
Github: https://github.com/huynguyengl99/chanx
 PyPI: https://pypi.org/project/chanx
 Documentation: https://chanx.readthedocs.io/
 Tutorial for newcomers: https://chanx.readthedocs.io/en/latest/tutorial-fastapi/prerequisites.html
  
Hope you all find it useful.
    submitted by    /u/huygl99  
 [link]   [comments]

FastChannels and ChanX: The missing toolkit for WebSocket handling in FastAPI

<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 all, I am a Jr Data Analyst in a MNC. Recently due to internal shifting, I have been assigned a FastAPI project which was earlier maintained by a Senior Developer. I am having a tough time understanding what&#39;s going on in the codebase ( in terms of the system). How do I tackle this issue? They expect me to start delivering within weeks or I will be sacked. Please help! </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/adamfloyd1506"> /u/adamfloyd1506 </a> <a href="https://www.reddit.com/r/FastAPI/comments/1so6bxn/help_i_am_having_a_tough_time_understanding_the/">[link]</a> &#32; <a href="https://www.reddit.com/r/FastAPI/comments/1so6bxn/help_i_am_having_a_tough_time_understanding_the/">[comments]</a>

Hello all,
 I am a Jr Data Analyst in a MNC.
 Recently due to internal shifting, I have been assigned a FastAPI project which was earlier maintained by a Senior Developer.
 I am having a tough time understanding what's going on in the codebase ( in terms of the system).
 How do I tackle this issue? They expect me to start delivering within weeks or I will be sacked.
 Please help!
    submitted by    /u/adamfloyd1506  
 [link]   [comments]

HELP! I am having a tough time understanding the codebase

<div class="md">Hi everyone, I’d really appreciate it if you could take a look at my code and give me some feedback. The functionality is fairly basic and not the main focus here — what I’m really interested in is evaluating the structure, organization, and overall code quality. I’m trying to improve my understanding of best practices, so any suggestions in that direction would be especially helpful. Feel free to point out anything that could be improved, whether it’s readability, naming conventions, modularity, or general design choices. Github: <a href="https://github.com/Petr201317/fastAPI_cinema">https://github.com/Petr201317/fastAPI_cinema</a> Thanks in advance for your time </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/Proper-Development90"> /u/Proper-Development90 </a> <a href="https://www.reddit.com/r/FastAPI/comments/1sob44k/look_for_feedback_on_my_fastapi_project/">[link]</a> &#32; <a href="https://www.reddit.com/r/FastAPI/comments/1sob44k/look_for_feedback_on_my_fastapi_project/">[comments]</a>

Hi everyone,
 I’d really appreciate it if you could take a look at my code and give me some feedback. The functionality is fairly basic and not the main focus here — what I’m really interested in is evaluating the structure, organization, and overall code quality. I’m trying to improve my understanding of best practices, so any suggestions in that direction would be especially helpful. Feel free to point out anything that could be improved, whether it’s readability, naming conventions, modularity, or general design choices.
 Github: https://github.com/Petr201317/fastAPI_cinema
 Thanks in advance for your time
    submitted by    /u/Proper-Development90  
 [link]   [comments]

Look for feedback on my fastapi project

<table> <tr><td> <a href="https://www.reddit.com/r/FastAPI/comments/1smc3vr/alternative_api_for_all_music_streaming_platforms/"> <img src="https://external-preview.redd.it/dHE8DOGsh2-YZ_zFo04DcNY47wYJp_KZ6LFrf_sU0-Y.jpeg?width=640&amp;crop=smart&amp;auto=webp&amp;s=3eaa64a8651c86bd2b957477be9ac3fdbdd48916" alt="Alternative API for all music streaming platforms" title="Alternative API for all music streaming platforms" /> </a> </td><td> &#32; submitted by &#32; <a href="https://www.reddit.com/user/Excellent_District22"> /u/Excellent_District22 </a> <a href="/r/spotifyapi/comments/1smc1xr/alternative_api_for_all_music_streaming_platforms/">[link]</a> &#32; <a href="https://www.reddit.com/r/FastAPI/comments/1smc3vr/alternative_api_for_all_music_streaming_platforms/">[comments]</a> </td></tr></table>

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

Alternative API for all music streaming platforms

<div class="md">I&#39;m working to improve the freely available documentation for Django. The official docs are great, but sometimes you just want a quick code example to see how something works. In my cheat sheet (it&#39;s kinda grown up into a more in-depth article) I cover some of these topics: <ol> <li>ORM and model queries.</li> <li>Basic encryption.</li> <li>Building auth views.</li> <li>Management commands.</li> <li>Forms.</li> <li>Tailwind setup and more</li> </ol> Learn more <a href="https://kevincoder.co.za/django-cheat-sheet">here</a>. Still a work in progress, so any suggestions or comments are most welcome. My goal is to add a valuable resource, almost like a pocket reference, to help new Django devs. I&#39;ll soon be covering DRF and other concepts as well. </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/KevinCoderZA"> /u/KevinCoderZA </a> <a href="https://www.reddit.com/r/djangolearning/comments/1smvdu1/django_cheat_sheet_tutorial_to_help_you_remember/">[link]</a> &#32; <a href="https://www.reddit.com/r/djangolearning/comments/1smvdu1/django_cheat_sheet_tutorial_to_help_you_remember/">[comments]</a>

I'm working to improve the freely available documentation for Django. The official docs are great, but sometimes you just want a quick code example to see how something works.
 In my cheat sheet (it's kinda grown up into a more in-depth article) I cover some of these topics:
  
ORM and model queries.
 Basic encryption.
 Building auth views.
 Management commands.
 Forms.
 Tailwind setup and more
  
Learn more here. 
 Still a work in progress, so any suggestions or comments are most welcome. My goal is to add a valuable resource, almost like a pocket reference, to help new Django devs.
 I'll soon be covering DRF and other concepts as well.
    submitted by    /u/KevinCoderZA  
 [link]   [comments]

Django cheat sheet tutorial to help you remember the essentials

<div class="md">Background to the question and the question itself So I think it&#39;s best if you have a look at this mp4 I recorded of what my site already does. This is just a public google drive link: <a href="https://drive.google.com/file/d/1cwvkN5prCDYBsRL4bjUfmotzdaQL74Ph/view?usp=sharing">https://drive.google.com/file/d/1cwvkN5prCDYBsRL4bjUfmotzdaQL74Ph/view?usp=sharing</a> As you can see in the MP4, when I click a word, it makes the form pop up on the right. That word is then shown in that form for submission. My question is, how do I make it so you can ALSO cursor-highlight a section of the text to pass it to the forms? What I already tried That text is wrapped in this: <pre><code>&lt;div id=&quot;current_text&quot; style=&quot;font-size: 20px; margin-top: 50px&quot;&gt; {{ text_content |hoverable_words:text_id }} &lt;/div&gt; </code></pre> Where text_content is the lorem ipsum text passed through a filter to make each highlightable/clickable. That is to say, CSS highlight, not text cursor highlighting. I had read that &#39;onselection&#39; is an event that triggers when you highlight stuff, so I made it an hx-trigger for the &quot;current_text&quot; div that contains the text. However, this just made that fire no matter what I did: clicked the div&#39;s background, clicked the words, whatever. I suspect it was a problem with how the event might have been bubbling up, but I&#39;m not sure. Anyways, I&#39;ll link and show what I got so far to make this happen. Disclaimers <ul> <li>Yes I know the code and UI is terrible. I&#39;m very much a functionality-first programmer, to refactor and prettify later.</li> <li>I color my divs so I can see them, it helps me troubleshoot CSS stuff.</li> <li>The context doesn&#39;t really matter for this question but if you must know, it&#39;s an app to help with constructing languages.</li> <li>I was gonna ask this later in a separate post, but if someone wants to tell me how I can handle events in the page without iterating through every word of my text again, that would be great But since it works, it&#39;s fine for now. But hey I&#39;ll take refactoring advice early.</li> </ul> Link to Repo and Relevant Files <a href="https://github.com/MatthewRicci12/conlangwebapp/tree/main/conlangapp">https://github.com/MatthewRicci12/conlangwebapp/tree/main/conlangapp</a> <ul> <li>views.py</li> </ul> The view that actually generates this is user_clicks_text(request, text_id) I am incredibly new to Django but have some React chops, so I might be a bit Reactbrained in how 90% of it is just seeing if I have certain &#39;state&#39;, but basically I&#39;m just checking if a bunch of crap has happened. If a form has been selected and which one, if the form is already up, if a token was selected, etc. <ul> <li>extract_text.html (what I&#39;ve shown in the video) &lt;div id=&quot;extract_text_master_container&quot;&gt; {% load hoverable_words %} &lt;div id=&quot;current_text&quot; style=&quot;font-size: 20px; margin-top: 50px&quot;&gt; {{ text_content |hoverable_words:text_id }} &lt;/div&gt; .... {% if form_up %} {% include &#39;partials/current_form.html&#39; with form_div_context=form_div_context only%} {% endif %}</li> </ul> The text, the lorem ipsum, is simply passed through a filter so everything can be clickable/highlightable. That filter is below. <ul> <li>hoverable_words.py @register.filter def hoverable_words(text, text_id): words = re.split(r&#39;(\s+)&#39;, text) # preserves whitespace result = &#39;&#39; for token in words: if token.strip(): url = reverse(&#39;user-clicks-text&#39;, args=[text_id]) result += f&#39;&lt;span class=&quot;word&quot; hx-post=&quot;{url}&quot; hx-target=&quot;body&quot; hx-vals=\&#39;{{&quot;form_up&quot;: 1, &quot;token&quot;: &quot;{token}&quot;}}\&#39;&gt;{token}&lt;/span&gt;&#39; else: result += token return mark_safe(result)</li> </ul> This simply makes everything highlightable and makes the click submit some &#39;state&#39; info which, again, I think might be a bit too Reactbrained. I know you CAN use React with Django but I&#39;d rather just keep on using HTMX. <ul> <li>current_form.html</li> </ul> Not super relevant, but it&#39;s that blue-backgrounded div with the actual forms. EDIT: Markdown on reddit is hard, looking at the actual github files themselves is probably clearest. </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/Drake15296"> /u/Drake15296 </a> <a href="https://www.reddit.com/r/djangolearning/comments/1slvqq9/trying_to_do_a_fancy_thing_where_both_clicking_on/">[link]</a> &#32; <a href="https://www.reddit.com/r/djangolearning/comments/1slvqq9/trying_to_do_a_fancy_thing_where_both_clicking_on/">[comments]</a>

Background to the question and the question itself
 So I think it's best if you have a look at this mp4 I recorded of what my site already does. This is just a public google drive link: https://drive.google.com/file/d/1cwvkN5prCDYBsRL4bjUfmotzdaQL74Ph/view?usp=sharing
 As you can see in the MP4, when I click a word, it makes the form pop up on the right. That word is then shown in that form for submission. My question is, how do I make it so you can ALSO cursor-highlight a section of the text to pass it to the forms?
 What I already tried
 That text is wrapped in this:
 <div id="current_text" style="font-size: 20px; margin-top: 50px"> {{ text_content |hoverable_words:text_id }} </div> 
 Where text_content is the lorem ipsum text passed through a filter to make each highlightable/clickable. That is to say, CSS highlight, not text cursor highlighting. I had read that 'onselection' is an event that triggers when you highlight stuff, so I made it an hx-trigger for the "current_text" div that contains the text. However, this just made that fire no matter what I did: clicked the div's background, clicked the words, whatever. I suspect it was a problem with how the event might have been bubbling up, but I'm not sure.
 Anyways, I'll link and show what I got so far to make this happen.
 Disclaimers
 
Yes I know the code and UI is terrible. I'm very much a functionality-first programmer, to refactor and prettify later.
 I color my divs so I can see them, it helps me troubleshoot CSS stuff.
 The context doesn't really matter for this question but if you must know, it's an app to help with constructing languages.
 I was gonna ask this later in a separate post, but if someone wants to tell me how I can handle events in the page without iterating through every word of my text again, that would be great But since it works, it's fine for now. But hey I'll take refactoring advice early.
 
Link to Repo and Relevant Files
 https://github.com/MatthewRicci12/conlangwebapp/tree/main/conlangapp
 
views.py
 
The view that actually generates this is user_clicks_text(request, text_id)
 I am incredibly new to Django but have some React chops, so I might be a bit Reactbrained in how 90% of it is just seeing if I have certain 'state', but basically I'm just checking if a bunch of crap has happened. If a form has been selected and which one, if the form is already up, if a token was selected, etc. 
 
extract_text.html (what I've shown in the video)
 <div id="extract_text_master_container"> {% load hoverable_words %} <div id="current_text" style="font-size: 20px; margin-top: 50px"> {{ text_content |hoverable_words:text_id }} </div> .... {% if form_up %} {% include 'partials/current_form.html' with form_div_context=form_div_context only%} {% endif %}
 
 The text, the lorem ipsum, is simply passed through a filter so everything can be clickable/highlightable. That filter is below.
 
hoverable_words.py
 @register.filter def hoverable_words(text, text_id): words = re.split(r'(\s+)', text) # preserves whitespace result = '' for token in words: if token.strip(): url = reverse('user-clicks-text', args=[text_id]) result += f'{token}' else: result += token return mark_safe(result)
 
 This simply makes everything highlightable and makes the click submit some 'state' info which, again, I think might be a bit too Reactbrained. I know you CAN use React with Django but I'd rather just keep on using HTMX.
 
current_form.html
 
Not super relevant, but it's that blue-backgrounded div with the actual forms.
 EDIT: Markdown on reddit is hard, looking at the actual github files themselves is probably clearest.
 submitted by /u/Drake15296 
 [link] [comments]

Trying to do a fancy thing where both clicking on a piece of text AND highlighting a section of text trigger the same event

<div class="md">I&#39;m doing a project, fully automated. Fetching data from an id card and saving it to the database is what I&#39;m working on now. but I tried so many tech stacks but no use. still some data is not fetching correctly. Don&#39;t know why. And also the client said API routing is not done in the project. What should I do. how to complete this project. </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/cum_onbaby"> /u/cum_onbaby </a> <a href="https://www.reddit.com/r/djangolearning/comments/1sn7pq2/python_django_api_doubt/">[link]</a> &#32; <a href="https://www.reddit.com/r/djangolearning/comments/1sn7pq2/python_django_api_doubt/">[comments]</a>

I'm doing a project, fully automated. Fetching data from an id card and saving it to the database is what I'm working on now. but I tried so many tech stacks but no use. still some data is not fetching correctly. Don't know why. And also the client said API routing is not done in the project. What should I do. how to complete this project. 
    submitted by    /u/cum_onbaby  
 [link]   [comments]

Python Django API Doubt

<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 just shipped ArchUnitPython, a library that lets you enforce architectural rules in Python projects through automated tests. The problem it solves: as codebases grow, architecture erodes. Someone imports the database layer from the presentation layer, circular dependencies creep in, naming conventions drift. Code review catches some of it, but not all, and definitely not consistently. This problem has always existed but is more important than ever in Claude Code, Codex times. LLMs break architectural rules all the time. So I built a library where you define your architecture rules as tests. Two quick examples: ```python <h1>No circular dependencies in services</h1> rule = project_files(&quot;src/&quot;).in_folder(&quot;/services/&quot;).should().have_no_cycles() assert_passes(rule) ``` ```python <h1>Presentation layer must not depend on database layer</h1> rule = project_files(&quot;src/&quot;) .in_folder(&quot;/presentation/&quot;) .should_not() .depend_on_files() .in_folder(&quot;/database/&quot;) assert_passes(rule) ``` This will run in pytest, unittest, or whatever you use, and therefore be automatically in your CI/CD. If a commit violates the architecture rules your team has decided, the CI will fail. Hint: this is exactly what the famous ArchUnit Java library does, just for Python - I took inspiration for the name is of course. Let me quickly address why this over linters or generic code analysis? Linters catch style issues. This catches structural violations — wrong dependency directions, layering breaches, naming convention drift. It&#39;s the difference between &quot;this line looks wrong&quot; and &quot;this module shouldn&#39;t talk to that module.&quot; Some key features: <ul> <li>Dependency direction enforcement &amp; circular dependency detection</li> <li>Naming convention checks (glob + regex)</li> <li>Code metrics: LCOM cohesion, abstractness, instability, distance from main sequence</li> <li>PlantUML diagram validation — ensure code matches your architecture diagrams</li> <li>Custom rules &amp; metrics</li> <li>Zero runtime dependencies, uses only Python&#39;s ast module</li> <li>Python 3.10+</li> </ul> Very curious what you think! <a href="https://github.com/LukasNiessen/ArchUnitPython">https://github.com/LukasNiessen/ArchUnitPython</a> </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/trolleid"> /u/trolleid </a> <a href="https://github.com/LukasNiessen/ArchUnitPython">[link]</a> &#32; <a href="https://www.reddit.com/r/djangolearning/comments/1sn50vd/i_built_archunit_for_python_enforce_architecture/">[comments]</a>

&#32; submitted by &#32; <a href="https://www.reddit.com/user/Boring-Purpose7901"> /u/Boring-Purpose7901 </a> <a href="/r/django/comments/1sm4ibk/i_encountered_an_error_while_trying_to_run_my/">[link]</a> &#32; <a href="https://www.reddit.com/r/djangolearning/comments/1sm4kfn/i_encountered_an_error_while_trying_to_run_my/">[comments]</a>

submitted by    /u/Boring-Purpose7901  
 [link]   [comments]

Hello, Python

Python Jobs 💼

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

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

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

Django Has Adopted Contributor Covenant 3

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

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

PyCharm & Django annual fundraiser

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

I git tired of “let’s build something together” going nowhere, so I tried this

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

Django Project Adopts Contributor Covenant 3

Json in relational db

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

Please help us find agencies working with Wagtail CMS

Dealing with side effects and sequential tasks in Django

Transactional email

ChanX: An extension library for Django Channels that makes building realtime applications a breeze

New Technical Governance - request for community feedback

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

Migrations in .gitignore during development

I built ArchUnit for Python: enforce architecture rules as unit tests.

I wrote a Postgres extension to handle Protobufs natively. Would love to know if this is useful for Django/gRPC setups.

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

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

From 2000 users to almost none: are handcrafted apps getting buried?

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

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

I built ArchUnit for Python: enforce architecture rules as unit tests.

I got tired of “let’s build something together” going nowhere, so I tried this

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

FastChannels and ChanX: The missing toolkit for WebSocket handling in FastAPI

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

HELP! I am having a tough time understanding the codebase

Look for feedback on my fastapi project

Alternative API for all music streaming platforms

Django cheat sheet tutorial to help you remember the essentials

Trying to do a fancy thing where both clicking on a piece of text AND highlighting a section of text trigger the same event

Python Django API Doubt

Django on vercel

I built ArchUnit for Python: enforce architecture rules as unit tests.

i encountered an error while trying to run my weather application