RizTech Academy logo
RizTech Academy

Python Django Web Development

Build and deploy a real database-backed web application, from first model to production.

Django gives you an admin panel, authentication, an ORM and security defaults on day one. For a small team that is an enormous head start.

This course goes past the basics into what Django is actually chosen for — the ORM in real depth (aggregation, transactions, custom managers, performance), its concurrency and background-work story, and the architecture decisions that keep a growing project sane. It builds one real application throughout: Nidaan, a clinic and diagnostic-lab manager — patients, appointments, doctors, test reports and billing — and finishes with it deployed, behind HTTPS, tested and hardened.

The aim is that you could be handed real Django project work and do it — including the hard parts. It assumes you already know Python. If you do not, take the Python Complete Foundation course first — learning both together is how people end up confused about which is which.

Who this is for

  • Developers comfortable with Python basics
  • Anyone who wants a backend they can ship quickly
  • Interns on the Full-Stack track

What you need first

  • Python Complete Foundation, or equivalent Python experience
  • Basic HTML (the Web UI Foundation course covers this)
  • Comfort with the command line

Tools you will use

Django 5.xPostgreSQLDjango REST FrameworkCeleryRedispytest-djangofactory_boyDocker

By the end you can

  • Model data properly and understand exactly what the ORM is doing
  • Use the ORM in depth — aggregation, F/Q expressions, custom managers, transactions and query performance
  • Build views, templates and forms, and use the admin as a real operational tool
  • Implement authentication, permissions and object-level access for sensitive data
  • Expose a REST API with Django REST Framework — filtering, auth and tests
  • Handle concurrency and background work — async views, safe transactions, task queues and caching
  • Write a test suite you trust, and review Django code well
  • Make sound architecture decisions as a project grows — where logic lives, and which patterns earn their place
  • Deploy a Django application with a production database, static files and HTTPS
Reference code

Stuck? Compare your work

Nidaan — the finished clinic & diagnostic-lab manager built across the course: models with constraints, the admin, staff views, a patient-scoped DRF API, and a test suite. Django 5.1; run it with python manage.py migrate && seed && runserver (use Python 3.12/3.13).

It is there for when you are stuck, not to start from. Type the code yourself first — copying it will teach you very little.

View on GitHub
Syllabus

12 modules, 60 lessons

Work through these in order. Each lesson is short enough to finish in one sitting and ends with something to build, not a quiz.

  1. 1

    Getting Started

    Project setup and understanding how a request flows through Django.

    1. Why Django, and when not to use it20 min
    2. Starting a project the right way30 min
    3. How a request flows through Django25 min
    4. Apps, settings and project structure30 min
  2. 2

    Models and the ORM

    Your data layer. Get this right and everything downstream is easier.

    1. Defining models and fields35 min
    2. Migrations, and how to not get stuck30 min
    3. ForeignKey, ManyToMany and OneToOne35 min
    4. QuerySets and filtering35 min
    5. select_related, prefetch_related and the N+1 problem30 min
    6. The Django admin as an operations tool30 min
  3. 3

    The ORM in Depth

    The reason people choose Django. Reporting, database-side logic, transactions and performance.

    1. Aggregation and annotation: reporting with the ORM35 min
    2. F() and Q(): database-side maths and complex lookups30 min
    3. Custom managers and querysets: naming your queries30 min
    4. Transactions, atomicity and database constraints35 min
    5. Indexes, EXPLAIN and query performance30 min
    6. Dropping to raw SQL, and when it is the right call25 min
  4. 4

    Views, Templates and Forms

    Turning data into pages people can use.

    1. Function-based views and URLs30 min
    2. Templates and template inheritance30 min
    3. Class-based views and when they help30 min
    4. Forms and ModelForms35 min
    5. Messages, redirects and the POST-redirect-GET pattern25 min
    6. Static files and user uploads25 min
  5. 5

    Authentication and Permissions

    Users, login, and controlling who can do what — including sensitive records.

    1. The user model, and customising it early30 min
    2. Login, logout and password reset30 min
    3. Permissions and access control30 min
    4. Object-level access for sensitive records30 min
    5. Django’s security defaults and what you must not disable25 min
  6. 6

    Building an API with DRF

    Exposing your data to a mobile app or frontend, properly.

    1. Django REST Framework: serializers and views35 min
    2. ViewSets, routers and pagination30 min
    3. Filtering, searching and ordering an API30 min
    4. Token and session authentication for APIs30 min
    5. Testing your API30 min
  7. 7

    Concurrency and Background Work

    Async views, safe database concurrency, task queues and caching — where each actually helps.

    1. Async views and the ASGI story: when they help35 min
    2. Transactions, select_for_update and the lost-update race35 min
    3. Background tasks and scheduled jobs with Celery35 min
    4. Caching: the cache framework and where it actually helps30 min
  8. 8

    Testing and Quality

    Confidence that a change did not break something else.

    1. What to test in a Django app, and what not to25 min
    2. Testing models and business logic30 min
    3. Testing views and forms30 min
    4. Fixtures and factories25 min
  9. 9

    Writing Django Worth Reading

    The habits that separate someone who can make it work from someone worth hiring.

    1. Fat models, thin views: where business logic belongs30 min
    2. Settings, environments and secrets, done right25 min
    3. Query discipline: performance you can see30 min
    4. Errors, logging and failing loudly25 min
    5. Reviewing Django code25 min
  10. 10

    Architecture and Patterns in Django

    The framework already encodes patterns. Which extra ones earn their place, and which do not.

    1. Django already encodes the patterns (MTV, and what that means)25 min
    2. The service-layer debate: fat models versus services35 min
    3. Custom managers as the repository pattern30 min
    4. Signals, and when not to reach for them25 min
    5. Structuring a project as it grows30 min
  11. 11

    Deployment

    Getting it live, safely.

    1. Production settings and the deploy checklist30 min
    2. Moving from SQLite to PostgreSQL25 min
    3. Static files and media in production30 min
    4. Containerising a Django app35 min
    5. Deploying, HTTPS and the launch checklist40 min
  12. 12

    Capstone: Nidaan, end to end

    Assemble the clinic and diagnostic-lab manager into a finished, hardened, deployed product.

    1. The brief: a clinic and diagnostic-lab manager25 min
    2. Designing the domain model45 min
    3. Building the core: appointments and test reports45 min
    4. The patient API and sensitive-data access40 min
    5. Concurrency safety, tests and going live45 min
Previous courseSwift and iOS DevelopmentNext courseJava + Spring Web Development

Learning this with a mentor is faster

Going through a course like this one is how you qualify for our six-month internship, for selected students, mostly from Pune. Clear the interview and you build real-world projects with my mentorship.

About the internshipAll courses