Framework Comparisons

Note: This section provides comparisons to other frameworks for developers familiar with them. If you're new to all frameworks, you can skip this section.

Frappe vs Django Concepts

Project Structure Comparison

Django Project:

myproject/
├── myproject/          # Project settings
│   ├── settings.py
│   ├── urls.py
│   └── wsgi.py
├── blog/              # Django app
│   ├── models.py
│   ├── views.py
│   └── urls.py
├── shop/              # Django app
└── users/             # Django app

Frappe Bench:

bench/
├── apps/
│   ├── frappe/        # Core framework (comparable to Django itself)
│   ├── erpnext/       # Complete business app (like Django + DRF + Celery + admin)
│   ├── hrms/          # HR Management app
│   └── my_custom_app/ # YOUR custom app
└── sites/
    └── mysite.com/    # Site instance (like Django project + database)
        ├── site_config.json
        └── private/files/

Conceptual Mapping

Django	Frappe	Notes
Model	DocType	But includes UI, permissions, API automatically
View	Controller method	Much less code needed
Admin	Desk	More powerful, auto-generated
DRF Serializer	Built-in	Automatic from DocType
Celery task	Background job	Built-in, no separate setup
signals	hooks.py	More structured
Management command	bench command	More discoverable

Key Architectural Differences

1. Multi-tenancy

   • Django: One app = one database (typically)
   • Frappe: One installation = many sites, each with own database

2. Background Jobs

   • Django: Requires Celery + Redis + worker setup
   • Frappe: Built-in queue system, just use enqueue()

3. Real-time

   • Django: Requires Channels + Redis + ASGI setup
   • Frappe: Socket.IO built-in, automatic for DocType updates

4. Admin/Management

   • Django: Admin for models, basic CRUD
   • Frappe: Full-featured Desk with reports, dashboards, permissions

5. API

   • Django: Manual DRF setup, serializers, views
   • Frappe: Automatic REST + RPC from DocType definitions

Code Comparison Example

Creating a "Customer" model:

Django (requires ~50+ lines):

# models.py
class Customer(models.Model):
    name = models.CharField(max_length=100)
    email = models.EmailField(unique=True)

# serializers.py
class CustomerSerializer(serializers.ModelSerializer):
    # ...

# views.py
class CustomerViewSet(viewsets.ModelViewSet):
    # ...

# urls.py
router.register(r'customers', CustomerViewSet)

# admin.py
@admin.register(Customer)
class CustomerAdmin(admin.ModelAdmin):
    # ...

Frappe (DocType JSON + ~10 lines Python):

// customer.json (auto-generated via UI or code)
{
  "name": "Customer",
  "fields": [
    { "fieldname": "customer_name", "fieldtype": "Data" },
    { "fieldname": "email", "fieldtype": "Data", "unique": 1 }
  ]
}

# customer.py (only for custom business logic)
import frappe
from frappe.model.document import Document

class Customer(Document):
    def validate(self):
        # Custom validation logic only
        pass

✅ Automatically includes:

• REST API (/api/resource/Customer)
• List view, Form view
• Search, Filters, Sorting
• Permissions (Create, Read, Update, Delete)
• Audit trail (created_by, modified_by, versions)
• Print formats, Email templates

When to Choose Frappe vs Django

Choose Frappe when:

• Building business applications (ERP, CRM, project management)
• Need multi-tenancy out-of-the-box
• Want rapid development with auto-generated UI
• Need role-based permissions and workflows
• Building for non-technical users who need customization

Choose Django when:

• Building consumer web apps (social media, e-commerce frontend)
• Need full control over every aspect
• Have highly custom UI requirements
• Team is already Django-expert
• Building API-only services

Hybrid Approach: Many teams use both: Frappe for back-office/admin tools, Django for customer-facing web apps.