Things Make More Sense the More You Actually Use Them

When I first started learning Django, I was honestly overwhelmed. I had already been doing frontend with React and some Node.js, so shifting my attention to Django felt a bit “weird.” It’s a Python backend framework, yes, but the structure, the patterns, and the way Django expects you to work were a different world entirely.

At the beginning, I had questions running through my head like:

• Why so many files?
• What’s with this settings.py and urls.py?
• Why are migrations so emphasized?
• Why should I use Django ORM instead of just raw SQL?

But here’s the truth I came to realize: things make more sense the more you actually use them.

It wasn’t until I rolled up my sleeves, built a couple of projects, and made mistakes that Django finally stopped feeling like a strange tool and started becoming natural.

The First Weird Feeling

If you’ve been coding in JavaScript land (React, Next.js, Node.js) and suddenly touch Django, the first shock is the structure.

A basic Django project might already look heavy:

myproject/
    manage.py
    myproject/
        __init__.py
        settings.py
        urls.py
        wsgi.py
    app1/
        __init__.py
        models.py
        views.py
        urls.py
        admin.py

At first, I was thinking: Why does it need to be this strict? Why not just one file and I code everything inside?

But then I discovered that Django is opinionated for a reason. The structure saves you from chaos when your project grows. What felt too much at the start, later became something I appreciated.

Models and the ORM

I remember avoiding Django models at first. I wanted to stick to raw SQL because that was what I understood better. But Django’s ORM is powerful.

Example: Instead of writing this in SQL:

SELECT * FROM blog_post WHERE published = true ORDER BY created_at DESC;

You can simply write in Django:

posts = BlogPost.objects.filter(published=True).order_by('-created_at')

At first, I thought: Okay, cool, but I can still write SQL. But when I started building larger features, I noticed the ORM made my life easier with relationships, migrations, and reusability.

Things clicked when I realized the ORM wasn’t just “sugar”, it was a productivity booster that handled edge cases I didn’t want to reinvent.

Views and Templates

Another thing that felt heavy was the concept of views.

A Django view function looks like this:

from django.http import HttpResponse

def home(request):
    return HttpResponse("Hello, Django world!")

Then later, I moved to class-based views:

from django.views import View
from django.http import HttpResponse

class HomeView(View):
    def get(self, request):
        return HttpResponse("Hello from a class-based view")

At first, I thought: This is too much, why so many ways to do one thing?

But the deeper I went, the more I saw the flexibility Django gives you. Small apps? Function-based views work perfectly. Bigger apps? Class-based views give you structure and reusability.

Again, it only made sense once I used it repeatedly.

Migrations

I’ll be honest: the first time I ran python manage.py makemigrations and migrate, I didn’t understand what was happening.

I thought: Why not just let me create tables directly?

But as projects grew, migrations became one of my favorite parts of Django. The framework remembers changes in your models, translates them into SQL, and lets you version-control your database schema.

This is gold when you’re working in a team or even just coming back to a project after months.

Admin Panel – The Hidden Gem

One thing that instantly made me respect Django was the Admin panel.

With just a few lines:

from django.contrib import admin
from .models import BlogPost

admin.site.register(BlogPost)

You suddenly have a ready-to-use dashboard where you can create, update, and delete records.

As a frontend dev, I was used to writing a full UI for such things. Django just gives it to you. That’s when I thought: Okay, this framework is different. It cares about developer productivity.

Security and Django’s Philosophy

Another area that only made sense after using Django deeply was its security-first approach.

Things like CSRF tokens, SQL injection prevention, password hashing, all baked in by default. At first, they looked like unnecessary “extra code.” Later, I realized they were there because Django is built for the real world, where applications must be safe by default.

Django vs Node.js / Express / Next.js

Since I also work with JavaScript frameworks like Node.js (with Express) and Next.js, I can clearly see the difference.

• Setup and Structure

  • Django: Heavy upfront, with strict structure.
  • Express: Lightweight and flexible, but you decide the structure.
  • Next.js: Balanced, with conventions but freedom in how you handle API routes.

• Database Handling

  • Django: ORM is built-in, migrations included.
  • Express/Next.js: You add libraries (Sequelize, Prisma, Mongoose) to get ORM features.

• Admin Panel

  • Django: Comes ready with a full admin dashboard.
  • Express/Next.js: You build or integrate your own.

• Security

  • Django: Security-first by default.
  • Express/Next.js: You add security middleware yourself.

• Learning Curve

  • Django: High at the start, but smooth later.
  • Express/Next.js: Easy to start, but harder to scale if you don’t enforce structure.

For me, coming from a JavaScript background, Django felt strict. But now, I see the value of its opinionated design. It’s like Django says: “I’ll guide you now so you won’t regret it later.”

The Turning Point

The more I coded in Django, the less I had to 'look up everything. Concepts that were once foreign like the MTV (Model-Template-View) pattern became second nature.

I found myself not just using Django but enjoying it. Building APIs, connecting with React frontends, or just creating admin dashboards, Django started feeling like a natural extension of Python.

The Lesson

If you’re learning Django or any framework really,

• Don’t judge it too quickly. The structure and “weirdness” often hide real benefits.
• Build projects, even small ones. The more you use it, the more natural it becomes.
• Don’t be afraid of the learning curve, Django is built to scale with you.
• Things always make more sense with practice, not just reading.

I started off wired about Django, almost frustrated, but now I feel at home with it. The admin panel, ORM, migrations, and security features all add up to make Django one of the most reliable backend frameworks out there.