Introduction

This guide is intended for those who have never used Django or have found it initially complex. The goal is to provide a complete and coherent overview, starting from the basics up to building a simple working application.

It is not a collection of shortcuts, but a reasoned explanation of how Django is organized and why it works this way.

Prerequisites

Before starting with Django, you should have:

Basic knowledge of Python
Minimal familiarity with HTML
A working development environment (Linux, macOS, or Windows)

No prior experience with other web frameworks is required.

What Django is and how it works

Django is a server-side web framework that provides a complete structure for developing web applications. Unlike more minimalist solutions, Django enforces a certain project organization and provides integrated tools to handle common problems.

The key concept is that many decisions are already made, reducing ambiguity in development.

Installation

It is recommended to use a virtual environment to isolate project dependencies.

python -m venv venv
source venv/bin/activate
pip install django

Check the installation:

django-admin --version

Creating a Django Project

A Django project represents the main container for the application.

django-admin startproject myproject
cd myproject

Initial structure:

myproject/
├── manage.py
└── myproject/
    ├── __init__.py
    ├── settings.py
    ├── urls.py
    ├── asgi.py
    └── wsgi.py

manage.py: utility to manage the project
settings.py: global configuration
urls.py: main routing
wsgi.py / asgi.py: interfaces for deployment

Running the Development Server

python manage.py runserver

Visit http://127.0.0.1:8000/ to see Django’s welcome page.

The Concept of an App

In Django, a project consists of one or more apps. An app represents a well-defined functionality (blog, users, comments, etc.).

Create the first app:

python manage.py startapp blog

App structure:

blog/
├── admin.py
├── apps.py
├── models.py
├── tests.py
└── views.py

INSTALLED_APPS = [
    ...
    'blog',
]

Views: Handling Requests

A view is a function (or class) that receives an HTTP request and returns a response.

Example in blog/views.py:

from django.http import HttpResponse

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

Routing

Connect a view to a URL.

blog/urls.py

from django.urls import path
from .views import home

urlpatterns = [
    path('', home),
]

myproject/urls.py

from django.urls import path, include

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

Templates: Separating Logic and Presentation

Django uses a template system to generate HTML.

Create the structure:

blog/
└── templates/
    └── blog/
        └── home.html

Example template:

<!DOCTYPE html>
<html>
<head>
    <title>Django Blog</title>
</head>
<body>
    <h1>Welcome to Django</h1>
</body>
</html>

Update the view:

from django.shortcuts import render

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

Models and the Database

Models define the structure of the data.

Example in blog/models.py:

from django.db import models

class Post(models.Model):
    title = models.CharField(max_length=200)
    content = models.TextField()
    created_at = models.DateTimeField(auto_now_add=True)

Create and apply migrations:

python manage.py makemigrations
python manage.py migrate

Django Admin

Create a superuser:

python manage.py createsuperuser

from django.contrib import admin
from .models import Post

admin.site.register(Post)

Access /admin/ to manage data.

Typical Workflow in Django

Define the model
Migrate the database
Create views
Configure URLs
Render with templates
Manage via admin or API

Common Mistakes for Beginners

Putting too much logic in views
Not properly separating apps
Modifying the database without migrations
Ignoring the framework’s recommended structure
Copying code without understanding it

What Comes Next

Relationships between models
Forms and validation
User authentication
Django REST Framework
Testing
Production deployment

Conclusion - Staff Note

From the Frontek.dev team’s perspective, Django is initially difficult to grasp, and many guides available on the web make the onboarding process more complicated than necessary. However, it is a very powerful tool. If you have the patience to experiment and work through tutorial after tutorial - something that will no longer be necessary after our Django Guide article - it will undoubtedly become a highly effective tool in your hands.

Django Guide - Part 1