⚙️ Django Admin Interface Customization

What the Admin Gives You Free

Register a model, log in, and Django already offers you searchable, paginated, permission-aware CRUD screens for your data — no HTML, no views, no forms written by hand. For internal tools and content management, this can save weeks of work.

💡 Analogy — the prefab house. The default admin is a prefabricated home: instantly habitable, with walls, plumbing, and power. It's functional but generic. Customizing it is the renovation — adding rooms (fieldsets), swapping fixtures (widgets), and wiring in smart features (actions and filters) until the space fits exactly how your team works.

Admin Architecture

A few cooperating pieces make the admin work. The one you'll touch daily is ModelAdmin — the class that declares how a single model looks and behaves.

• AdminSite — the container that owns the URLs and the index page.
• ModelAdmin — per-model configuration; where almost all your work happens.
• Inlines — edit related objects on the parent's page.
• Templates — the HTML you can override for deep visual changes.

Registering Models

The bare minimum is one line per model. The moment you want to customize, attach a ModelAdmin — and the decorator form is the modern idiom.

# admin.py — bare registration
from django.contrib import admin
from .models import Book

admin.site.register(Book)

# admin.py — the decorator idiom (preferred)
from django.contrib import admin
from .models import Book


@admin.register(Book)
class BookAdmin(admin.ModelAdmin):
    pass   # customization options go here

Both approaches are equivalent; @admin.register(Book) just keeps the class and its registration together.

Shaping the List View

The list view is the grid of all rows. A few options turn it from a wall of __str__ values into a real data console.

@admin.register(Book)
class BookAdmin(admin.ModelAdmin):
    list_display = ("title", "author", "publisher", "price", "is_bestseller")
    list_filter = ("publisher", "is_bestseller", "publication_date")
    search_fields = ("title", "author__name", "isbn")
    date_hierarchy = "publication_date"
    ordering = ("-publication_date", "title")
    list_per_page = 25
    list_editable = ("price", "is_bestseller")
    list_display_links = ("title",)

Computed Columns

Not every column has to be a stored field. Add a method to your ModelAdmin (or a property on the model) and list its name in list_display. The modern way to label and configure it is the @admin.display decorator.

from datetime import date
from django.contrib import admin


@admin.register(Book)
class BookAdmin(admin.ModelAdmin):
    list_display = ("title", "author", "price", "age", "price_tier")

    @admin.display(description="Age", ordering="publication_date")
    def age(self, obj):
        if obj.publication_date:
            years = (date.today() - obj.publication_date).days // 365
            return f"{years} years"
        return "—"

    @admin.display(description="Tier")
    def price_tier(self, obj):
        if obj.price < 10:
            return "Budget"
        elif obj.price < 30:
            return "Regular"
        return "Premium"

The Detail View & Fieldsets

The detail view is the add/edit form. fieldsets groups fields into labeled sections — collapsible if you like — which tames long forms.

@admin.register(Book)
class BookAdmin(admin.ModelAdmin):
    fieldsets = (
        ("Basic information", {
            "fields": ("title", "author", "publisher"),
        }),
        ("Publishing details", {
            "fields": ("publication_date", "isbn", "page_count"),
            "classes": ("collapse",),
            "description": "Optional publication metadata.",
        }),
        ("Sales", {
            "fields": ("price", "stock", "is_bestseller"),
        }),
    )
    autocomplete_fields = ("author",)   # search-as-you-type FK picker
    readonly_fields = ("isbn",)
    save_on_top = True

• fieldsets — group fields; "classes": ("collapse",) hides a section by default.
• autocomplete_fields — replaces a huge foreign-key dropdown with a search box (the target admin needs search_fields).
• readonly_fields — display a value without letting it be edited.
• save_on_top — adds save buttons above the form as well as below.

Inlines

Inlines let you edit related rows on the parent's page — chapters while editing a book, comments while editing a post. Two flavors: TabularInline (compact rows) and StackedInline (full form per item).

from django.contrib import admin
from .models import Book, Chapter


class ChapterInline(admin.TabularInline):
    model = Chapter
    extra = 1              # one blank row to add a new chapter
    fields = ("title", "page_start", "page_end")
    min_num = 1
    max_num = 50


@admin.register(Book)
class BookAdmin(admin.ModelAdmin):
    inlines = [ChapterInline]

Custom Actions

Actions run an operation over the rows a user has ticked in the list view. Select some rows, choose the action, hit Go. They're perfect for batch state changes and exports.

import csv
from django.contrib import admin
from django.http import HttpResponse


@admin.register(Book)
class BookAdmin(admin.ModelAdmin):
    actions = ["mark_bestseller", "export_as_csv"]

    @admin.action(description="Mark selected books as bestsellers")
    def mark_bestseller(self, request, queryset):
        updated = queryset.update(is_bestseller=True)
        self.message_user(request, f"{updated} book(s) marked as bestsellers.")

    @admin.action(description="Export selected books as CSV")
    def export_as_csv(self, request, queryset):
        response = HttpResponse(content_type="text/csv")
        response["Content-Disposition"] = "attachment; filename=books.csv"
        writer = csv.writer(response)
        writer.writerow(["Title", "Author", "Price"])
        for book in queryset:
            writer.writerow([book.title, book.author, book.price])
        return response

Filters & Branding

Custom list filter

When a built-in filter isn't enough, subclass SimpleListFilter to define your own sidebar options and the query behind each.

from django.contrib import admin
from django.utils import timezone


class PublishedThisYearFilter(admin.SimpleListFilter):
    title = "published this year"
    parameter_name = "this_year"

    def lookups(self, request, model_admin):
        return (("yes", "Yes"), ("no", "No"))

    def queryset(self, request, queryset):
        year = timezone.now().year
        if self.value() == "yes":
            return queryset.filter(published_at__year=year)
        if self.value() == "no":
            return queryset.exclude(published_at__year=year)
        return queryset


@admin.register(Post)
class PostAdmin(admin.ModelAdmin):
    list_filter = (PublishedThisYearFilter, "status")

Rebranding the site

The quickest branding change is three attributes on the default admin site — no custom AdminSite subclass required.

# admin.py (or your project's urls.py / apps.py)
from django.contrib import admin

admin.site.site_header = "Bookstore Administration"
admin.site.site_title = "Bookstore Admin"
admin.site.index_title = "Management dashboard"

Worked Example: Blog Admin

Here's a realistic admin that ties the pieces together — a slug auto-filled from the title, computed columns, comment inlines, and batch publish/draft actions.

# admin.py
from django.contrib import admin
from django.utils import timezone
from .models import Category, Post, Comment


class CommentInline(admin.TabularInline):
    model = Comment
    extra = 0
    fields = ("author_name", "content", "is_approved")
    readonly_fields = ("author_name", "content")


@admin.register(Post)
class PostAdmin(admin.ModelAdmin):
    list_display = ("title", "author", "category", "status",
                    "comment_count", "published_at")
    list_filter = ("status", "category", "created_at")
    search_fields = ("title", "content")
    prepopulated_fields = {"slug": ("title",)}      # slug follows title
    date_hierarchy = "created_at"
    inlines = [CommentInline]
    actions = ["make_published", "make_draft"]
    save_on_top = True

    @admin.display(description="Comments")
    def comment_count(self, obj):
        return obj.comments.count()

    @admin.action(description="Publish selected posts")
    def make_published(self, request, queryset):
        updated = queryset.filter(status="draft").update(
            status="published", published_at=timezone.now())
        self.message_user(request, f"{updated} post(s) published.")

    @admin.action(description="Move selected posts back to draft")
    def make_draft(self, request, queryset):
        updated = queryset.update(status="draft")
        self.message_user(request, f"{updated} post(s) set to draft.")

    def save_model(self, request, obj, form, change):
        # Stamp the author on first save.
        if not change:
            obj.author = request.user
        super().save_model(request, obj, form, change)


@admin.register(Category)
class CategoryAdmin(admin.ModelAdmin):
    list_display = ("name", "slug")
    prepopulated_fields = {"slug": ("name",)}

Hands-on Exercise

# admin.py
from django.contrib import admin
from .models import Product


@admin.register(Product)
class ProductAdmin(admin.ModelAdmin):
    list_display = ("name", "price", "stock", "is_active", "stock_status")
    list_filter = ("is_active",)
    search_fields = ("name",)
    actions = ["deactivate"]

    @admin.display(description="Stock")
    def stock_status(self, obj):
        if obj.stock == 0:
            return "Out"
        elif obj.stock < 10:
            return "Low"
        return "OK"

    @admin.action(description="Deactivate selected products")
    def deactivate(self, request, queryset):
        updated = queryset.update(is_active=False)
        self.message_user(request, f"{updated} product(s) deactivated.")

Summary & Quiz

📚 Further Reading

• Django docs — The admin site
• Django docs — Admin actions
• Django docs — List filters

🚀 What's Next?

You've built server-rendered pages, forms, and an admin. Next we open the door to APIs: an overview of Django REST Framework, which lets your Django backend serve JSON to mobile apps and single-page frontends.