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 - the rest of the guide is self-contained.

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.