Django Developer Roadmap

from django.db import models

class Article(models.Model):
    title = models.CharField(max_length=200)
    published = models.DateField(auto_now_add=True)

class Book(models.Model):
    isbn = models.CharField(max_length=13, unique=True)
    pages = models.PositiveIntegerField(default=0)

    class Meta:
        ordering = ['isbn']

class Profile(models.Model):
    bio = models.TextField(blank=True)
    score = models.DecimalField(max_digits=5, decimal_places=2)

python manage.py makemigrations blog
python manage.py migrate

qs = Article.objects.filter(published__year=2026).order_by('-published')
first = qs.first()

from django.db.models import Count

Article.objects.values('author_id').annotate(n=Count('id'))

class Article(models.Model):
    slug = models.SlugField()

    def __str__(self):
        return self.slug

class PublishedManager(models.Manager):
    def get_queryset(self):
        return super().get_queryset().filter(status='published')

urlpatterns = [
    path('posts/<int:pk>/', views.post_detail, name='post-detail'),
]

from django.shortcuts import render, get_object_or_404

def post_detail(request, pk):
    post = get_object_or_404(Post, pk=pk)
    return render(request, 'blog/detail.html', {'post': post})

from django.views.generic import ListView

class PostList(ListView):
    model = Post
    paginate_by = 10

from django.urls import path

urlpatterns = [
    path('articles/<slug:slug>/', views.article, name='article'),
]

from django.urls import path

urlpatterns = [
    path('users/<uuid:id>/', views.user_detail),
]

urlpatterns = [
    path('blog/', include('blog.urls')),
]

{% extends "base.html" %}
{% block title %}Hello{% endblock %}

{{ article.title|default:"Untitled"|upper }}
{% if article.published %}Live{% endif %}

return render(request, 'blog/list.html', {
    'posts': posts,
    'active_tab': 'blog',
})

{% extends "base.html" %}
{% block content %}
  <article>...</article>
{% endblock %}

{% load static %}
<link rel="stylesheet" href="{% static 'app/main.css' %}">

STATIC_URL = 'static/'
STATIC_ROOT = BASE_DIR / 'staticfiles'

from django import template

register = template.Library()

@register.filter
def twice(value):
    return value * 2

def nav(request):
    return {'nav_items': getattr(request, '_nav_items', [])}

class ContactForm(forms.Form):
    subject = forms.CharField(max_length=100)
    message = forms.CharField(widget=forms.Textarea)

class SignupForm(forms.Form):
    email = forms.EmailField()
    age = forms.IntegerField(min_value=0)

def clean_username(self):
    data = self.cleaned_data['username']
    if data.lower() == 'admin':
        raise forms.ValidationError('Reserved name.')
    return data

class ArticleForm(forms.ModelForm):
    class Meta:
        model = Article
        fields = ['title', 'body']

from django.contrib import admin
from .models import Article

admin.site.register(Article)

admin.site.site_header = 'Softaims internal'
admin.site.site_title = 'Admin'

@admin.register(Article)
class ArticleAdmin(admin.ModelAdmin):
    list_display = ('title', 'published')
    search_fields = ('title',)

class ArticleAdmin(admin.ModelAdmin):
    date_hierarchy = 'published'
    list_filter = ('status',)

@admin.action(description='Mark as published')
def make_published(modeladmin, request, queryset):
    queryset.update(status='published')

from django.contrib.auth import authenticate, login

def my_login(request):
    user = authenticate(request, username=u, password=p)
    if user:
        login(request, user)

INSTALLED_APPS += [
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
]

AUTH_USER_MODEL = 'accounts.User'

from django.contrib.auth.decorators import login_required

@login_required
def dashboard(request):
    return render(request, 'dash.html')

user.has_perm('blog.change_article')

from django.contrib.auth.hashers import make_password
stored = make_password('long-random-secret')

class User(AbstractUser):
    display_name = models.CharField(max_length=80)

AUTHENTICATION_BACKENDS = [
    'django.contrib.auth.backends.ModelBackend',
]

MEDIA_URL = 'media/'
MEDIA_ROOT = BASE_DIR / 'media'

STATIC_URL = 'static/'
STATIC_ROOT = BASE_DIR / 'staticfiles'

class Document(models.Model):
    file = models.FileField(upload_to='docs/%Y/%m/')

STATICFILES_STORAGE = 'django.contrib.staticfiles.storage.StaticFilesStorage'

from django.conf import settings
from django.conf.urls.static import static

urlpatterns += static(settings.MEDIA_URL, document_root=settings.MEDIA_ROOT)

MIDDLEWARE = [
    'django.middleware.security.SecurityMiddleware',
    'django.contrib.sessions.middleware.SessionMiddleware',
    # ...
]

<form method="post">
  {% csrf_token %}
  ...
</form>

{{ user_supplied|escape }}

X_FRAME_OPTIONS = 'DENY'

PASSWORD_HASHERS = [
    'django.contrib.auth.hashers.PBKDF2PasswordHasher',
]

from django.http import JsonResponse

def list_items(request):
    data = list(Item.objects.values('id', 'name')[:50])
    return JsonResponse({'items': data})

class ItemCreate(CreateView):
    model = Item
    fields = ['name']

from django.core import serializers
data = serializers.serialize('json', Article.objects.all())

# Plain Django JSON endpoint pattern
return JsonResponse(serializer_as_dict(obj))

from django.http import JsonResponse

def ping(request):
    return JsonResponse({'ok': True})

urlpatterns = [
    path('items/', views.ItemList.as_view()),
    path('items/<int:pk>/', views.ItemDetail.as_view()),
]

from django.contrib.auth.decorators import login_required

@login_required
def me(request):
    return JsonResponse({'user': request.user.username})

from django.contrib.auth.decorators import permission_required

@permission_required('blog.add_article')
def create_article(request):
    ...

from django.test import TestCase

class HomeTests(TestCase):
    def test_ok(self):
        r = self.client.get('/')
        self.assertEqual(r.status_code, 200)

class ArticleModelTests(TestCase):
    def test_str(self):
        a = Article(title='Hi')
        self.assertEqual(str(a), 'Hi')

from django.test import TestCase

class MathTests(TestCase):
    def test_add(self):
        self.assertEqual(1 + 1, 2)

response = self.client.post('/login/', {'username': 'a', 'password': 'b'})
self.assertEqual(response.status_code, 302)

# pytest.ini
[pytest]
DJANGO_SETTINGS_MODULE = config.settings

python manage.py check --deploy

gunicorn config.wsgi:application --bind 0.0.0.0:8000

location / {
    proxy_pass http://127.0.0.1:8000;
    proxy_set_header Host $host;
}

import os
SECRET_KEY = os.environ['DJANGO_SECRET_KEY']

FROM python:3.12-slim
WORKDIR /app
COPY . .
RUN pip install -r requirements.txt

# Example CI step
python manage.py test --parallel

class Chapter(models.Model):
    book = models.ForeignKey(Book, on_delete=models.CASCADE, related_name='chapters')

class Comment(models.Model):
    post = models.ForeignKey(Post, on_delete=models.CASCADE, related_name='comments')

class Profile(models.Model):
    user = models.OneToOneField(settings.AUTH_USER_MODEL, on_delete=models.CASCADE)

class Article(models.Model):
    tags = models.ManyToManyField('Tag', related_name='articles')

class BookQuerySet(models.QuerySet):
    def published(self):
        return self.filter(status='published')

class HandField(models.Field):
    description = 'A playing card hand'

from django.db.models import F
Item.objects.update(stock=F('stock') - 1)

class OrderedBook(Book):
    class Meta:
        proxy = True
        ordering = ['title']

class SimpleMiddleware:
    def __init__(self, get_response):
        self.get_response = get_response

    def __call__(self, request):
        response = self.get_response(request)
        return response

from django.db.models.signals import post_save
from django.dispatch import receiver

@receiver(post_save, sender=Article)
def notify(sender, instance, **kwargs):
    ...

MIDDLEWARE = [
    'django.middleware.security.SecurityMiddleware',
    'django.contrib.sessions.middleware.SessionMiddleware',
    'django.middleware.common.CommonMiddleware',
]

def get_request_id(get_response):
    def middleware(request):
        request.request_id = uuid.uuid4().hex
        return get_response(request)
    return middleware

post_save.connect(receiver, sender=Order, weak=False)

async def stats(request):
    count = await Article.objects.acount()
    return JsonResponse({'count': count})

import os
from django.core.asgi import get_asgi_application

os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'config.settings')
application = get_asgi_application()

from django.http import JsonResponse

async def ping(request):
    return JsonResponse({'ok': True})

async def first_article():
    return await Article.objects.afirst()

# ASGI entry composes HTTP (Django) with other protocol routes.
from django.core.asgi import get_asgi_application
django_asgi = get_asgi_application()

daphne -b 0.0.0.0 -p 8001 config.asgi:application

from django.core.cache import cache

def expensive():
    hit = cache.get('key')
    if hit is None:
        hit = compute()
        cache.set('key', hit, 300)
    return hit

{% load cache %}
{% cache 500 sidebar request.user.id %}
  ...
{% endcache %}

CACHES = {
    'default': {
        'BACKEND': 'django.core.cache.backends.locmem.LocMemCache',
    }
}

# Typical pattern (backend package name varies)
# 'BACKEND': 'django_redis.cache.RedisCache'

qs = Article.objects.select_related('author').prefetch_related('tags')

from django.core.management.base import BaseCommand

class Command(BaseCommand):
    help = 'Example'

    def handle(self, *args, **options):
        self.stdout.write('done')

# myapp/management/commands/hello.py
from django.core.management.base import BaseCommand

class Command(BaseCommand):
    def handle(self, *args, **options):
        self.stdout.write(self.style.SUCCESS('Hello'))

class Command(BaseCommand):
    def add_arguments(self, parser):
        parser.add_argument('name', type=str)

from django.core.management import call_command

call_command('migrate', verbosity=0)

0 * * * * cd /app && /app/.venv/bin/python manage.py send_digests

parser.add_argument(
    '--dry-run',
    action='store_true',
    help='Print actions without writing',
)