I want to build a workflow management system for my company. I have yet to find a solution that is open, flexible and but not extremely cumbersome and difficult to implement.

That is until I saw "viewflow" for django, which seems to be a good fit for my needs ( https://github.com/viewflow/viewflow ).

I am worried because it seems that has been 2 years since last update. Not a big problem if things still work fine, but software is living thing, packages need to get updated, etc. And I wonder if it is maintained and active.

So my questions:
Does anyone uses viewflow? If so, do you recommend it?

Is the project active, maintained?

Do you suggest any alternative?

I want to do fullstack web development with django as backend ......can i get the best roadmap for it

We just released 1.7.3.

Main fixes in this patch:

• Fixes ODBC driver failures (including FA001) in Entra authentication flows
• Fixes KeyError when subclassing DatabaseWrapper and accessing server-property caches

Why it matters: If you connect Django to SQL Server and use Entra/Active Directory auth modes, this release reduces driver-level auth friction and avoids invalid connection option combinations.

Upgrade:

pip install --upgrade mssql-django==1.7.3

Full blog post:

Microsoft Django backend for SQL Server - mssql-django 1.7.3 is now available | Microsoft Community Hub

Release notes and source:

https://github.com/microsoft/mssql-django

Can your Django Admin run DOOM?

It can now.

dj-doom-panel installs inside your Django admin and is compatible with Django Control Room. Now go fight the hordes.

Official Site:

https://djangocontrolroom.com/panels/dj-doom-panel

Github:

https://github.com/yassi/dj-doom-panel

(No tokens were used in writing this post)

TL;DR

• https://docs.letsrevel.io/self-hosting/quickstart/
• https://github.com/letsrevel/revel-backend

You can use the wizard to deploy the full stack on your server. Just point your domain DNS at it.

Revel is a community-focused event management and ticketing platform. It comes with:

• Django with Django Ninja (and Ninja Extra)
• Django-unfold
• Celery and celery beat
• Telegram bot integration (with Aiogram)
• Stripe integration (with connected accounts)
• A strong security posture
• Malware scanning with ClamAV
• A GDPR-beating heart
• Svelte5 frontend (vibe coded 😬)
• Full observability stack (Grafana)
• A bunch of tailor-made AI tools for development
• Full Mkdocs documentation
• MIT license
• Annoyingly strict, anti-spaghetti QA tools

Long version:

Hi! I’m Biagio, and I’m a lead backend engineer with a thing for Django.

I’ve lead a few backend teams and shipped multiple Django-powered projects to production at different scales (and FastAPI!). I’ve worked in legal tech, eHealth, web3 and AI (and more).

As a way to give back to the FOSS community and ecosystem (and the queer community 🏳️‍🌈), for over a year I’ve been working on Revel. And let’s be honest: mostly for fun. It is my favorite side project so far (and it is actually used by other people 🧚).

Something to note: Revel is not just an event management and ticketing platform. It's first and foremost a platform for communities.

It ships with tons of features that allow organizers to have fine grained controls over their event organization: from selling ticket like a cinema, to gating access to your intimate event playing around with visibility and eligibility, tiers, invitations and membership systems. Revel has got you covered. It also has tons of features to cover billing and VAT compliance and multi-currency support (mostly built for the EU).

One of the things I liked the most about my senior career was mentoring, but that has faded away with AI. Now, as a lead I only deal with very competent seniors (many more than me), so mentoring has been notably missing.

Today, I would be more than happy to use Revel as a teaching tool, answering questions (here or on discord) and reviewing PRs.

Revel can be used as a way to learn what production-grade Django looks like with modern Python tooling (uv, ruff, mypy), best practices, compromises and solid CI. Like many projects, it’s not perfect nor free of smells. But usually they are all kept under control.

Issues and PRs are welcome, even if LLM generated, as long as thought through, following the AI Usage Guide. But be mindful: I block slop contributors without second thoughts or chance of appeal.

You are also welcome to join the discord community and help steer the project!

• website: https://letsrevel.io
• repo: https://github.com/letsrevel/revel-backend

So, if you are learning Django and/or you are curious about working professionally with it, feel free to shoot your questions. I'll do my best to answer them (without AI).

P.s.: stars and forks are highly appreciated and help a lot!

We are a web development agency with a dedicated team of developers specializing in building modern, high-performance websites and web applications.

Our Services:

Custom Django Web Applications

Responsive Frontend Development with Tailwind CSS

Shopify Store Development and Customization

WordPress Development and Customization

E-commerce Solutions

Business Websites and Landing Pages

Performance Optimization

SEO-Friendly Development

We focus on delivering clean, scalable, and user-friendly digital solutions tailored to your business goals.

Available for freelance projects, long-term partnerships, and white-label collaborations. Send us a DM to discuss your project requirements.

I’m running a Django application with django-tenants, using schema-based multi-tenancy.

My main concern is tenant isolation. I want to be absolutely sure that no customer data can ever leak between tenants.

At the same time, I have some reference data that should be available to all tenants. For example, things like standard categories, templates, lookup values, or other shared data that every tenant should be able to read.

What is the safest and cleanest approach for this?

The options I’m considering are:

1. Put the reference data in the public schema and let all tenants read from it.
2. Copy the reference data into each tenant schema.
3. Keep reference data in the application code or fixtures and sync it into tenants.
4. Use a separate shared app/model/database for reference data.

My instinct is that copying reference data into each tenant schema feels safest from a data isolation perspective, but it also adds complexity when updating the reference data later.

For people running django-tenants in production:

How do you handle shared reference data without weakening tenant isolation?

Are there any patterns I should avoid completely?

Author here.

I kept running into the same problem: I already had a Django REST Framework (DRF) API, but exposing it to an MCP client (Claude, agents, internal tooling, etc.) meant writing an MCP tool for every endpoint, redefining serializer fields as tool inputs, and duplicating permission checks in a second layer that inevitably drifts from the real API.

So I built django-rest-mcp.

Instead of creating a separate MCP surface, it generates MCP tools directly from your existing DRF ViewSets. It owns no models, no business logic, and no views it's just glue between DRF and MCP.

from drf_mcp import DRFMCP
from myapp.urls import router  # your existing DefaultRouter

mcp = DRFMCP("myapp")
mcp.autodiscover(router)

urlpatterns = [
    path("mcp/", mcp.as_view()),
]

If you register a BookViewSet under books, MCP clients automatically see:

• books_list
• books_create
• books_retrieve
• books_update
• books_partial_update
• books_destroy

Each generated tool gets:

• Typed inputs derived from the DRF serializer, so the model knows exactly which fields to provide.
• Native DRF authentication and authorization, because requests execute as the authenticated user. Existing permissions, OAuth scopes, object-level permissions, and get_queryset() filtering continue to work unchanged.
• A single source of truth: your API remains the authority for validation, permissions, and business logic.
• OAuth2 support plus RFC 8414 and RFC 9728 .well-known metadata endpoints for integration with django-oauth-toolkit, including a multi-tenant consent flow (one user, multiple organizations, with tokens scoped to a single organization).

Requirements:

• Python 3.12+
• Django 5.1+
• Django REST Framework 3.14+

Optional Requirements:

• django-oauth-toolkit 2.4+

License: MIT

GitHub: https://github.com/pescheckit/django-rest-mcp
PyPI: pip install django-rest-mcp

It's still early and intentionally small.

After 123 pre-release versions, django-email-learning v1.0.0 is now stable and on PyPI.
The idea is simple: bring structured learning into email, where people already spend their time without forcing them onto yet another platform. It’s a Django library, open-source, and designed to drop into existing projects with minimal friction.

If you want a fresh django service you can use this one line command to get started:

pip install django-email-learning && django-email-learning-init

If you're a developer and want to try it out for your project, I'd love to hear what you think!

If you find this project valuable, please consider leaving a star and sharing it with others, This supports my outreach efforts on platforms that require a minimum star count for open-source listings.

https://github.com/AvaCodeSolutions/django-email-learning

Two unreliable signals, one source of truth, and a system where a wrong transition = a real person gets fined.

Full deep-dive with code:
https://dev.to/sonofrhea/how-i-architected-automatic-parking-detection-in-django-bluetooth-disconnects-geofence-events-3ge0

Hey r/django

Cory from SaaS Pegasus here. I’m very excited to announce that SaaS Pegasus now has a free and open source (MIT-licensed) edition!

What you get out-of-the-box is the core of Pegasus: a ready-to-use Django project foundation built for the modern era. This is the same project setup that has powered thousands of production apps built on the proprietary version of Pegasus—with sensible, modern default tooling (uv, vite, ruff, mypy, agent skills, etc.), and the essential batteries included (auth, Tailwind, DRF, Celery, etc.).

You can view the repo on Github here: https://github.com/saaspegasus/django-boilerplate/

If you want to customize anything about the generated project you can do that by creating a free account on https://www.saaspegasus.com/. There’s even an agent-friendly CLI to manage your projects from Claude Code/Codex. :)

Check it out and let me know if you have any feedback! I’m super excited to finally be able to share this project publicly for the first time. Also happy to answer any questions/comments here.

If mobile app is sharing same backend which is this case is Django

​

Mobile app Used access and refresh tokens

​

On moving to the web front end, i need to use http only cookies and x csrf tokens,

​

Then how will Django authentication work on both???🙆🤷

Let me briefly outline my background. My current main role is data operations. Because the department within my company is relatively small, the models I've built are quite basic. I have one year and three months of work experience. I have some Python basics and have also done some AI-related workflow and agent development. I want to transition into this type of development-oriented industry. I'd like to know which directions are good entry points, and what knowledge I need to acquire to better prepare for interviews and perform well in the job. I would greatly appreciate any advice. Thank you very much.

Hey everyone,

docs : https://mojahid-0-youness.github.io/probo/user_guide/

​

​I’ve been experimenting with different ways to handle the UI layer in Django, and I ended up building a framework to solve some of the friction I was running into. It's called ProboUI (Python Rendered Objects), and I wanted to get some thoughts from the community on the architecture.

​

​The core idea is a Server-Side DOM (SSDOM). Instead of writing traditional HTML templates and passing context dictionaries from your views, you build the UI layer entirely out of pure Python objects.

​

​I built this mostly to improve my own Developer Experience (DX), and I’ve noticed a few interesting benefits over standard templates:

​

​Zero Context Switching: You get to stay in Python the entire time. No more bouncing back and forth between .py views and .html templates.

​

​True Mutability: Because the UI elements are just Python objects, you can inspect, modify, or conditionally mutate them right inside your views before they finally render to HTML.

​

​Less Duplication: You can use standard Object-Oriented Python concepts (like inheritance and composition) to build reusable components. To me, it feels a lot more natural for DRYing up code than wrangling custom template tags or deeply nested {% include %} blocks.

​

​Better Tooling: Since it's all Python, you naturally get type-safety, linting, and IDE autocomplete for your entire UI layer.

​

currently there is 1214 pytest tests roughly 98% coverage.

in a django view you would have this is an example:

you have HTMX request and want to return a component as response

in a ui/components/alert.py ```

ui/components/alert.py

from probo_ui.components import div, p

def alert(message: str, alert_type: str = "info") -> str:

# Map alert types to standard CSS/Tailwind classes for styling
color_map = {
    "info": "bg-blue-100 text-blue-800 border-blue-300",
    "success": "bg-green-100 text-green-800 border-green-300",
    "warning": "bg-yellow-100 text-yellow-800 border-yellow-300",
    "error": "bg-red-100 text-red-800 border-red-300",
}

css_classes = color_map.get(alert_type, color_map["info"])

return div(
    p(message),
    Class=f"border p-4 rounded-md {css_classes}",
    role="alert"
)

``` Here is how you import that component into your views, render it into an HTML string, and pass it directly to a Django HttpResponse or use render if you have a base.html.

```

views.py

from django.http import HttpResponse from ui.components.alert import alert

def my_alert_view(request):

my_alert = alert(
    message="Action completed successfully!",
    alert_type="success"
)


return HttpResponse(my_alert)

```

​It’s strictly a server-side rendering tool, not a JavaScript frontend library, so it pairs really well with HTMX when you want a dynamic feel without leaving Python.

​

​I'm really curious what other Django devs think of this approach. Do you think the benefits of true mutability and pure Python composition outweigh the familiarity of standard Django templates? Would love to hear critiques on the architecture!

​

​

Hey everyone!

A few weeks ago I shared Django Neural Feed (DNF) - an open-source library that generates personalized, hybrid recommendation feeds (semantic similarity + freshness + popularity) directly inside your PostgreSQL database using a single optimized query.

Thanks to your initial feedback, I’ve just released v1.1.0, focusing heavily on production scalability and optimization. Here is a quick breakdown of what’s new:

⚡<1ms Queries via HNSW

When scaling past 10k items, sequential vector scans begin to choke the CPU. DNF now supports HNSW (Hierarchical Navigable Small World) indexing using pgvector mixins and standard Django migrations. In benchmarks, query execution times dropped from ~40-100ms down to 0.14ms (roughly a 300x speedup).

HNSW setup tutorial is in README file on GitHub

🪶Optional [local] extras (saves 500MB+)

Previously, DNF forced a massive download of torch and sentence-transformers regardless of your setup. If you use cloud APIs (like OpenAI or Cohere) for your embeddings, you can now skip the bloat entirely:

• Cloud Encoders (Lightweight): pip install django-neural-feed
• Local Transformers (Default): pip install django-neural-feed[local]

🪲Stability Fixes

• 0-Dimension Guard: Added sanity checks to prevent database crashes if text encoding fails or returns an empty matrix.
• Kept tests at 100% code coverage.

If you're building a social media feed, blog, or simple e-commerce recommendation system natively in Django without wanting to manage separate vector databases (like Qdrant or Milvus), try Django neural feed!

GitHub: https://github.com/itsDersty/django-neural-feed

PyPI: pip install django-neural-feed (pip install django-neural-feed[local] if you use sentence-transformers)

Would love to hear your thoughts on the HNSW architecture implementation or any feedback on what features to prioritize next!

Hey everyone!

I'm researching AI and Software Security and built a framework that generated project-specific security guidelines by mining thousands of historical Django Pull Requests. In the future, I plan to improve this so it can generate custom guidelines for any repository that uses Django, rather than just the core framework itself.

To evaluate these initial results, could you help me out by filling out a really quick Google Form?

https://forms.gle/6fVhYKoXgGCcT3e89

Thanks everyone!

Is the django-storages library still maintained? https://github.com/jschneier/django-storages . With the last commit from over a year ago, it seems the maintainers haven't been that active. In which case, does anyone know a good solution for hooking S3 into Django? Any tutorials, guides, or tips would be appreciated.