My Learning Django Experience: A Beginner’s Journey

Curious about Django but don’t know where to start? Here’s how I went from confusion to building my first app—one step at a time

I wanted to explore how full-stack apps worked, how backends communicate with databases, and how to use Python in web development, which led me to Django. When I first heard about Django, I had no clue what it actually was. 😅 I just knew it had something to do with building websites using Python, which sounded both exciting and intimidating. As someone who had just started exploring web development, I was more comfortable with HTML, CSS, and a bit of JavaScript. So, the idea of using a Python framework felt like stepping into a whole new world.

But I was curious. I wanted to know how full-stack apps were made, how backends worked, and how data moved from a user’s screen to a database. That’s when I decided to dive into Django. And let me tell you—it was a rollercoaster 🎢 (in a good way!).

From setting up my first Django project to figuring out how templates, views, and models connect, every step taught me something new—not just about code, but about being patient with myself while learning something complex.

What Helped Me Understand Django Better

When I started, Django honestly felt like magic. I’d write some code, refresh the page, and suddenly something new would show up. But magic only works if you understand the tricks, right?

Here’s what made a huge difference for me:

» Understanding the MVT Pattern

At first, I was like... isn’t it supposed to be MVC? But Django has its own spin: Model-Template-View. Realising how these three work together was a game-changer.

• Models handled my data

• Views acted like the logic layer

• Templates displayed it all beautifully on screen

» Starting Small (And Breaking Things)

Instead of jumping into big projects, I started by building a basic Blog app. I created models for posts, added views to display them, and used templates for the front-end. I messed up the routing so many times, but fixing those mistakes helped me remember stuff better than any tutorial ever could.

» The Admin Panel is a Life Saver

When I discovered Django’s admin panel, I felt like a hacker in a movie 😂 It made data entry and testing so much easier. And customizing it later felt like such a boss move.

» Using Documentation (Yes, really!)

I used to avoid documentation like it was some ancient scroll, but Django’s docs? Surprisingly beginner-friendly. Once I started using them, I got stuck way less.

Getting Started with Django (The Setup Part)

Before I could jump into building anything, I had to set up Django properly. And to be honest? The first time I saw all those commands and folders—it felt a lot. 😵‍💫 But with a little practice, the steps started to feel familiar.

Here’s the setup flow I followed:

1. Set Up a Virtual Environment
   First, I created a virtual environment to keep my project clean and organized

    python -m venv env
   

   Then activated it:

   • On Windows:

       env\Scripts\activate
     

   • On macOS/Linux:

       source env/bin/activate
     

2. Installed Django
   Inside the virtual environment, I installed Django using pip:

    pip install django
   

3. Created My First Django Project
   This command spun up the base structure of my Django app:

    django-admin startproject mysite
   

4. Opened It in VS Code
   I used VS Code to work with my project (and the Python extension really helped):

    code .
   

Ran the Development Server
Just to check if everything worked, I ran:

python manage.py runserver

Then visited http://127.0.0.1:8000/ in the browser—and ta-da! Django’s welcome page appeared. That tiny moment gave me such a boost. 😄

My First Django App (Where Things Got Real)

After setting up the project, I created my first app inside it. Django encourages breaking your project into smaller apps, each with its own purpose.

To start, I ran:

python manage.py startapp blog

Suddenly, a whole bunch of new files and folders appeared. At first, it was a little intimidating. But then I realized—Django wants to keep things organized. It just looked like a lot because I didn’t know what each part did… yet.

Inside this app, I slowly began to learn:

• models.py – for database structure

• views.py – for logic

• urls.py – for routing

• templates/ – for HTML files

Connecting the app to the project meant updating the settings.py and project urls.py—it was a little messy at first, but it made more sense each time I did it.

Setting Up My First View and URL (Feeling Like a Real Developer 😎)

Once the app was ready, it was time to actually see something in the browser. That meant creating a view and mapping it to a URL.

In views.py, I wrote my very first function-based view:

from django.http import HttpResponse

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

It was simple, but the moment I saw “Hello, Django!” on my screen, it felt so real. Like, I actually built this 😭✨

Then, I added a urls.py inside the app and linked it in the project’s main urls.py.

blog/urls.py:

from django.urls import path
from . import views

urlpatterns = [
    path('', views.home, name='home'),
]

project/urls.py:

from django.contrib import admin
from django.urls import path, include

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

That moment when it all worked? Chef’s kiss. 👩‍💻💥

From Plain Text to Real HTML: Learning Templates

After printing “Hello, Django!” on the screen with HttpResponse, I realized… yeah, that’s cool, but it doesn’t look like a real website yet. Time to learn about templates!

I created a folder called templates inside my app folder (blog/templates/blog/) and added an HTML file:

blog/templates/blog/home.html

<!DOCTYPE html>
<html>
<head>
    <title>My First Django Page</title>
</head>
<body>
    <h1>Hello from Django Templates!</h1>
    <p>This is my first template-based view. 🎉</p>
</body>
</html>

Then, I updated the views.py to use render():

from django.shortcuts import render

def home(request):
    return render(request, 'blog/home.html')

I also made sure to add 'DIRS': [] in settings.py was fine, since Django automatically finds templates inside app folders if they’re named correctly. Still, it felt like magic when it worked.

And that moment when I saw my HTML in the browser?

Actual joy. I was like:

Making It Pretty: Adding Static Files (CSS & Images)

Once my template was working, I wanted to make it look… well, less plain. So, I started learning about static files in Django — things like CSS, JavaScript, and images that give your site personality.

First, I created a folder called static inside my app folder like this:

blog/
├── static/
│   └── blog/
│       └── styles.css

Then I added a simple CSS file:

styles.css

body {
    background-color: #f9f9f9;
    font-family: Arial, sans-serif;
    text-align: center;
}
h1 {
    color: #4a90e2;
}

And in my HTML (home.html), I loaded it:

{% load static %}
<!DOCTYPE html>
<html>
<head>
    <title>Django Static Demo</title>
    <link rel="stylesheet" href="{% static 'blog/styles.css' %}">
</head>
<body>
    <h1>Hello from Django Templates!</h1>
    <p>Now with styling ✨</p>
</body>
</html>

Also, I made sure STATICFILES_DIRS and STATIC_URL were set properly in settings.py.
It looked like a lot of setup at first — but after doing it once, it really wasn’t so scary anymore.

What’s Next?

After getting a bit comfortable with views and templates, I slowly began exploring Django models and how they connect with databases. But that’s a topic that deserves its own space.

My Biggest Challenges (And How I Overcame Them)

Learning Django wasn’t all smooth sailing. Here are a few things that tripped me up—and what eventually helped:

❌ URL Routing Confusion
For the longest time, I kept mixing up path() and include(). And don’t even get me started on naming views properly. But slowly, after messing up enough times, I started to see how Django’s URL patterns are actually really flexible (and powerful).

✔ What Helped: Drawing the route flow on paper! Just sketching out how the URL is supposed to work with views and templates made a huge difference.

❌ Template Tags and Filters
I was like, what even is {% for post in posts %}? It looked weird and broke often if I missed one bracket 😩

✔ What Helped: I stopped copy-pasting and actually typed out each tag. That helped me remember the syntax, and I started understanding what was happening behind the scenes.

❌ Working with Models and Migrations
Every time I changed a field and forgot to make migrations… Django screamed at me 😅. I also had no clue what to do when I renamed something and it broke the database.

✔ What Helped: Learning the flow — makemigrations → migrate → check admin → celebrate! 🎉
And if things got too messy, dropping the database and starting over helped me learn faster than fixing 100 errors.

What I Built (And Why It Meant a Lot)

Even though they were small, the first projects I built gave me the confidence to keep going.

📝 Simple Blog App – My first Django app where I learned models, views, templates, and admin basics. I used dummy content and saw real-time updates through the admin dashboard. It felt magical.

✅ To-Do List App – This helped me understand CRUD operations, form handling, and how to deal with user input.

🔐 Login Page – I dipped my toes into authentication. It felt complicated at first, but once I got the basics, I realized how powerful Django is for handling user systems.

Each small app taught me something new and helped me connect the dots.

» Final Thoughts

Django can feel overwhelming at first, but the more I built and broke things, the clearer it became. I’m still figuring things out, but that’s part of the fun. If you’re also learning Django—don’t worry about getting everything right the first time. You’re doing great. 💚

🔄 Quick Recap: What I Learned from My First Django Project

• ✅ Set up a virtual environment and installed Django to keep things clean.

• 🏁 Started my first project and app, even if I had no clue what all the files meant.

• 🌐 Created views and connected them with URLs — messed up a few times but got the hang of it.

• 🧩 Understood the MVT pattern (Model-View-Template) — and how each part plays its role.

• 📝 Built HTML templates and learned how to render them with views.

• 🎨 Added static files like CSS to make the site look better.

• 🔁 Practiced migrations and models — and learned to read errors without panicking 😅

• 📚 Used the Django docs more than I expected (and now I love them!)

• 💡 Most important lesson: It’s okay to break things while learning — just keep building.