Getting Started with Django: A Journey into a Mature Web Framework

Introduction

There's something uniquely satisfying about picking up an older, well-established technology for the first time. After years of hearing about Django, the Python web framework that has been around since 2005, I finally decided to give it a try for a recent project. What I found was a refreshingly pragmatic tool that prioritizes clarity and ease of use. Here are my impressions and key takeaways from starting with Django.

Explicitness Over Magic: Why Django Feels More Approachable

When I attempted to learn Ruby on Rails a few years ago, I was initially excited by its conventions. However, after stepping away from my Rails project for a few months, I struggled to recall how everything fit together. A line like resources :topics in routes.rb doesn't tell you where the actual topic routes are defined—you have to remember the implied defaults. For someone like me, who often leaves projects untouched for long periods, that hidden complexity became a barrier.

Django takes a different approach. Instead of relying on invisible conventions, it forces you to be explicit. My small Django project consists of just five main files (ignoring settings.py):

• urls.py — for routing
• models.py — database models
• views.py — business logic
• admin.py — admin interface configuration
• tests.py — test cases

If I need to find where an HTML template is referenced, it's clearly spelled out in one of these files. There's no need to guess or dig through hidden documentation. This explicitness makes it much easier to return to a project after months away and immediately understand the structure.

The Built-in Admin: A Hidden Gem

For my project, I needed a simple admin panel to manually view and edit database records. Django ships with a full-featured admin interface out of the box. With just a few lines of code, I had a powerful backend up and running.

Here's an example from my admin configuration:

@admin.register(Zine)
class ZineAdmin(admin.ModelAdmin):
    list_display = ["name", "publication_date", "free", "slug", "image_preview"]
    search_fields = ["name", "slug"]
    readonly_fields = ["image_preview"]
    ordering = ["-publication_date"]

This small snippet:

• Defines which columns appear in the list view
• Enables search on name and slug fields
• Makes the image preview read-only
• Orders the list by publication date (newest first)

The admin is highly customizable and saved me from writing a separate crud interface. For many projects, it's more than sufficient.

Enjoying the ORM: From SQL Skeptic to Fan

I used to be firmly in the "just write raw SQL" camp. I considered object-relational mappings unnecessary abstractions. Django's ORM changed my mind. It's both intuitive and powerful, especially its approach to joins.

Consider this query:

Zine.objects
    .exclude(product__order__email_hash=email_hash)

This single line traverses five tables—zines, zine_products, products, order_products, and orders. The double underscore (__) tells Django to follow relationships implicitly. I only needed to define ManyToManyField links in my models, and Django handles the rest.

The ORM also provides:

• Filtering with filter(), exclude(), and field lookups
• Aggregation with annotate() and aggregate()
• Preloading related data via select_related() and prefetch_related()

It strikes a good balance between convenience and control. When needed, I can still drop into raw SQL using connection.execute(), but I rarely need to.

Final Thoughts

Django has been a pleasure to learn. Its explicitness, built-in admin, and smart ORM make it ideal for projects that need to be maintainable over the long term. If you're considering a full-stack framework and value clarity over convention, Django is worth a serious look.