Django for Beginners

Models, views, auth, DRF 20h

Take your Python skills to the web by building full Django apps with models, templates, authentication, and simple REST APIs using Django REST Framework (DRF). You will move from an empty virtual environment to a working, database-backed site that users can sign into and interact with, plus a small API that exposes your data.

▶ Start this training

Self-paced. Work through each module at your own speed.

Who this is for

Developers who already know basic Python and front-end fundamentals and want to build real full-stack web applications. If you have written scripts or small tools and now want to ship something people can log into and use, this is the next step.

Prerequisites

Comfort with Python basics (functions, modules, virtual environments) and HTML/CSS. JavaScript experience is helpful but not required. You should be able to run Python commands from a terminal and install packages with pip.

By the end you will be able to:

5 outcomes

Set up Django projects with virtual environments and reusable apps, and understand where settings, URLs, templates, and static files live in the project.
Design models, run migrations, and use the Django admin effectively to create, edit, and inspect data without writing raw SQL.
Build views, templates, and forms for full CRUD workflows so users can create, update, and delete records through the browser.
Implement user registration, login, logout, and basic permissions so different users see only the data they are allowed to see.
Expose core data via simple REST APIs using Django REST Framework, and test those APIs using the browsable DRF interface or command-line tools.

Training highlights

4 key themes

Django project/app structure, settings, URL routing, and the request/response cycle from browser to view and back.
Models, migrations, and the Django admin for quick CRUD operations during development and early prototyping.
Views, templates, and form handling for real user flows like registration, listing items, and editing records.
Authentication, login-required views, and DRF-powered JSON endpoints that make your project feel like a modern web app.

Syllabus

4 sections

Week 1

Environment setup, creating a new Django project and app, understanding URL routing, and defining your first models and migrations. You will explore the Django admin and use it to add and edit sample data.

Week 2

Views and templates, static files, and CRUD forms for your core model. You will build user registration, login, and logout, and use messages or flash alerts to confirm actions.

Week 3

Django REST Framework basics: serializers, API views, and simple JSON endpoints for your app’s core data. You will test your API and understand how it connects to your models.

Capstone Project

Ship a full CRUD Django app (such as a task tracker, notes app, or simple portfolio) with user authentication and a DRF-powered API that exposes at least part of your data.

Training plan

6 modules

Follow these modules step by step. Each one included concrete tasks so you actually learn and ship something real. You could have treated each module as one focused work session or spread the steps across several days.

Module 1: Setup and First Django Project

Create and activate a Python virtual environment (for example, using python -m venv .venv and source .venv/bin/activate or the Windows equivalent). Verify that your shell shows the environment name.
Install Django with pip install django and use django-admin startproject to create a new project folder. Run python manage.py runserver and confirm that the default Django welcome page appears.
Create your first app (for example, 'core' or 'tasks') using python manage.py startapp and add it to INSTALLED_APPS in settings.py so Django knows about it.
Open urls.py and wire a simple view function that returns an HttpResponse. Confirm in the browser that visiting the path shows your custom message instead of the default page.

Module 2: Models, Migrations, and Admin

Define a simple model (such as Task, Note, or Post) with fields like title, description, created_at, and updated_at. Add __str__ to return a helpful label.
Run python manage.py makemigrations and python manage.py migrate to create the database tables. Confirm that your new app’s migrations appear in the output.
Create a superuser account with python manage.py createsuperuser and log into the Django admin at /admin. Add a few sample records through the admin UI.
Register your model with the admin, and customize list_display and search_fields so the list page shows key fields and allows quick searching.

Module 3: Views, URLs, and Templates

Create function-based views for listing all objects and showing a single detail page. Use Django’s ORM to query your model and pass the data into the template context.
Add URL patterns in your app’s urls.py and include them from the project’s main urls.py using include(). Confirm that both the list and detail pages work.
Create base.html with a shared header, navigation, and footer, then build list and detail templates that extend this base and render the model data.
Set up static files (CSS and images), configure STATIC_URL and STATICFILES_DIRS, and confirm that your templates load a stylesheet with {% load static %} and <link> tags.

Module 4: Forms and Authentication

Create a ModelForm or Form class for your main model, and build create and edit views that display the form, validate input, and save data to the database.
Add delete functionality with a confirmation page so users can safely remove records. Use Django’s messages framework to show success notifications.
Implement user signup, login, and logout using Django’s built-in auth views or your own custom views and templates. Make sure the navigation updates based on whether the user is authenticated.
Use the login_required decorator (or LoginRequiredMixin) to protect views so only logged-in users can access certain pages. Optionally, filter data so each user only sees their own records.

Module 5: Intro to Django REST Framework

Install Django REST Framework (pip install djangorestframework), add it to INSTALLED_APPS, and configure a basic REST_FRAMEWORK setting if needed.
Create a serializer for your main model that defines the fields to expose as JSON. Test the serializer in a Django shell to see the output.
Build a simple APIView, generic view, or ViewSet that lists objects and allows creating new ones via POST. Wire it up in urls.py under an /api/ path.
Open the API endpoint in your browser to use DRF’s browsable API. Try making test requests from the UI or from a tool like curl or HTTPie to confirm that JSON data is returned and accepted.

Practice & Assessment

Build a small CRUD app such as a task manager, bookmarks app, or notes app. The app should allow creating, updating, and deleting items through forms.
Implement user-specific data so each authenticated user sees only their own records. Test with two different user accounts.
Expose a read-only API endpoint for your main model using DRF. Confirm that the endpoint returns the correct JSON and is filtered by user if applicable.
Document the steps required to set up the project from scratch (clone, install, migrate, createsuperuser, runserver) so you can deploy or share the app later.