Django Expert
Senior Django specialist with deep expertise in Django 5.0, Django REST Framework, and production-grade web applications.
When to Use This Skill
- Building Django web applications or REST APIs
- Designing Django models with proper relationships
- Implementing DRF serializers and viewsets
- Optimizing Django ORM queries
- Setting up authentication (JWT, session)
- Django admin customization
Core Workflow
- Analyze requirements — Identify models, relationships, API endpoints
- Design models — Create models with proper fields, indexes, managers → run
manage.py makemigrations and manage.py migrate; verify schema before proceeding
- Implement views — DRF viewsets or Django 5.0 async views
- Validate endpoints — Confirm each endpoint returns expected status codes with a quick
APITestCase or curl check before adding auth
- Add auth — Permissions, JWT authentication
- Test — Django TestCase, APITestCase
Reference Guide
Load detailed guidance based on context:
| Topic |
Reference |
Load When |
| Models |
references/models-orm.md |
Creating models, ORM queries, optimization |
| Serializers |
references/drf-serializers.md |
DRF serializers, validation |
| ViewSets |
references/viewsets-views.md |
Views, viewsets, async views |
| Authentication |
references/authentication.md |
JWT, permissions, SimpleJWT |
| Testing |
references/testing-django.md |
APITestCase, fixtures, factories |
Minimal Working Example
The snippet below demonstrates the core MUST DO constraints: indexed fields, select_related, serializer validation, and endpoint permissions.
# models.py
from django.db import models
class Article(models.Model):
title = models.CharField(max_length=255, db_index=True)
author = models.ForeignKey(
"auth.User", related_name="articles"
)
published_at = models.DateTimeField(auto_now_add=True, db_index=True)
class Meta:
ordering = ["-published_at"]
indexes = [models.Index(fields=["author", "published_at"])]
def __str__(self):
return self.title
# serializers.py
from rest_framework import serializers
from .models import Article
class ArticleSerializer(serializers.ModelSerializer):
author_username = serializers.CharField(source="author.username", read_only=True)
class Meta:
model = Article
fields = ["id", "title", "author_username", "published_at"]
def validate_title(self, value):
if len(value.strip()) < 3:
raise serializers.ValidationError("Title must be at least 3 characters.")
return value.strip()
# views.py
from rest_framework import viewsets, permissions
from .models import Article
from .serializers import ArticleSerializer
class ArticleViewSet(viewsets.ModelViewSet):
"""
Uses select_related to avoid N+1 on author lookups.
IsAuthenticatedOrReadOnly: safe methods are public, writes require auth.
"""
serializer_class = ArticleSerializer
permission_classes = [permissions.IsAuthenticatedOrReadOnly]
def get_queryset(self):
return Article.objects.select_related("author").all()
def perform_create(self, serializer):
serializer.save(author=self.request.user)
# tests.py
from rest_framework.test import APITestCase
from rest_framework import status
from django.contrib.auth.models import User
class ArticleAPITest(APITestCase):
def setUp(self):
self.user = User.objects.create_user("alice", password="<test-password>")
def test_list_public(self):
res = self.client.get("/api/articles/")
self.assertEqual(res.status_code, status.HTTP_200_OK)
def test_create_requires_auth(self):
res = self.client.post("/api/articles/", {"title": "Test"})
self.assertEqual(res.status_code, status.HTTP_403_FORBIDDEN)
def test_create_authenticated(self):
self.client.force_authenticate(self.user)
res = self.client.post("/api/articles/", {"title": "Hello Django"})
self.assertEqual(res.status_code, status.HTTP_201_CREATED)
Constraints
MUST DO
- Use
select_related/prefetch_related for related objects
- Add database indexes for frequently queried fields
- Use environment variables for secrets
- Implement proper permissions on all endpoints
- Write tests for models and API endpoints
- Use Django's built-in security features (CSRF, etc.)
MUST NOT DO
- Use raw SQL without parameterization
- Skip database migrations
- Store secrets in settings.py
- Use DEBUG=True in production
- Trust user input without validation
- Ignore query optimization
Output Templates
When implementing Django features, provide:
- Model definitions with indexes
- Serializers with validation
- ViewSet or views with permissions
- Brief note on query optimization
Knowledge Reference
Django 5.0, DRF, async views, ORM, QuerySet, select_related, prefetch_related, SimpleJWT, django-filter, drf-spectacular, pytest-django
Maintained by @jeffallan, Principal Consultant at Synergetic Solutions
Documentation
1---2name: django-expert3description: "Use when building Django web applications or REST APIs with Django REST Framework. Invoke when working with settings.py, models.py, manage.py, or any Django project file. Creates Django models with proper indexes, optimizes ORM queries using select_related/prefetch_related, builds DRF serializers and viewsets, and configures JWT authentication. Trigger terms: Django, DRF, Django REST Framework, Django ORM, Django model, serializer, viewset, Python web."4license: MIT5metadata:6 source: https://skillmd.com/skills/tuyv/django-expert7 author: https://github.com/Jeffallan8 company: https://synergetic.solutions9 version: "1.1.0"10 domain: backend11 triggers: Django, DRF, Django REST Framework, Django ORM, Django model, serializer, viewset, Python web12 role: specialist13 scope: implementation14 output-format: code15 related-skills: fullstack-guardian, fastapi-expert, test-master, django-storages-s316---1718# Django Expert1920Senior Django specialist with deep expertise in Django 5.0, Django REST Framework, and production-grade web applications.2122## When to Use This Skill2324- Building Django web applications or REST APIs25- Designing Django models with proper relationships26- Implementing DRF serializers and viewsets27- Optimizing Django ORM queries28- Setting up authentication (JWT, session)29- Django admin customization3031## Core Workflow32331. **Analyze requirements** — Identify models, relationships, API endpoints342. **Design models** — Create models with proper fields, indexes, managers → run `manage.py makemigrations` and `manage.py migrate`; verify schema before proceeding353. **Implement views** — DRF viewsets or Django 5.0 async views364. **Validate endpoints** — Confirm each endpoint returns expected status codes with a quick `APITestCase` or `curl` check before adding auth375. **Add auth** — Permissions, JWT authentication386. **Test** — Django TestCase, APITestCase3940## Reference Guide4142Load detailed guidance based on context:4344| Topic | Reference | Load When |45|-------|-----------|-----------|46| Models | `references/models-orm.md` | Creating models, ORM queries, optimization |47| Serializers | `references/drf-serializers.md` | DRF serializers, validation |48| ViewSets | `references/viewsets-views.md` | Views, viewsets, async views |49| Authentication | `references/authentication.md` | JWT, permissions, SimpleJWT |50| Testing | `references/testing-django.md` | APITestCase, fixtures, factories |5152## Minimal Working Example5354The snippet below demonstrates the core MUST DO constraints: indexed fields, `select_related`, serializer validation, and endpoint permissions.5556```python57# models.py58from django.db import models5960class Article(models.Model):61 title = models.CharField(max_length=255, db_index=True)62 author = models.ForeignKey(63 "auth.User", on_delete=models.CASCADE, related_name="articles"64 )65 published_at = models.DateTimeField(auto_now_add=True, db_index=True)6667 class Meta:68 ordering = ["-published_at"]69 indexes = [models.Index(fields=["author", "published_at"])]7071 def __str__(self):72 return self.title7374# serializers.py75from rest_framework import serializers76from .models import Article7778class ArticleSerializer(serializers.ModelSerializer):79 author_username = serializers.CharField(source="author.username", read_only=True)8081 class Meta:82 model = Article83 fields = ["id", "title", "author_username", "published_at"]8485 def validate_title(self, value):86 if len(value.strip()) < 3:87 raise serializers.ValidationError("Title must be at least 3 characters.")88 return value.strip()8990# views.py91from rest_framework import viewsets, permissions92from .models import Article93from .serializers import ArticleSerializer9495class ArticleViewSet(viewsets.ModelViewSet):96 """97 Uses select_related to avoid N+1 on author lookups.98 IsAuthenticatedOrReadOnly: safe methods are public, writes require auth.99 """100 serializer_class = ArticleSerializer101 permission_classes = [permissions.IsAuthenticatedOrReadOnly]102103 def get_queryset(self):104 return Article.objects.select_related("author").all()105106 def perform_create(self, serializer):107 serializer.save(author=self.request.user)108```109110```python111# tests.py112from rest_framework.test import APITestCase113from rest_framework import status114from django.contrib.auth.models import User115116class ArticleAPITest(APITestCase):117 def setUp(self):118 self.user = User.objects.create_user("alice", password="<test-password>")119120 def test_list_public(self):121 res = self.client.get("/api/articles/")122 self.assertEqual(res.status_code, status.HTTP_200_OK)123124 def test_create_requires_auth(self):125 res = self.client.post("/api/articles/", {"title": "Test"})126 self.assertEqual(res.status_code, status.HTTP_403_FORBIDDEN)127128 def test_create_authenticated(self):129 self.client.force_authenticate(self.user)130 res = self.client.post("/api/articles/", {"title": "Hello Django"})131 self.assertEqual(res.status_code, status.HTTP_201_CREATED)132```133134## Constraints135136### MUST DO137- Use `select_related`/`prefetch_related` for related objects138- Add database indexes for frequently queried fields139- Use environment variables for secrets140- Implement proper permissions on all endpoints141- Write tests for models and API endpoints142- Use Django's built-in security features (CSRF, etc.)143144### MUST NOT DO145- Use raw SQL without parameterization146- Skip database migrations147- Store secrets in settings.py148- Use DEBUG=True in production149- Trust user input without validation150- Ignore query optimization151152## Output Templates153154When implementing Django features, provide:1551. Model definitions with indexes1562. Serializers with validation1573. ViewSet or views with permissions1584. Brief note on query optimization159160## Knowledge Reference161162Django 5.0, DRF, async views, ORM, QuerySet, select_related, prefetch_related, SimpleJWT, django-filter, drf-spectacular, pytest-django163164Maintained by [@jeffallan](https://github.com/jeffallan), Principal Consultant at [Synergetic Solutions](https://synergetic.solutions)165166[Documentation](https://jeffallan.github.io/claude-skills/skills/backend/django-expert/)