A long introduction or why you should read first and do later
My story
You know, when you're just starting to learn something, like a new programming language or, in our case, the Django framework, you're suddenly bombarded with all sorts of recommendations, top lists, reviews, opinions, and tutorials. And don't get me wrong, it's not bad, it's just confusing.
I personally didn't learn from books or YouTube tutorials at first... Okay, I lied, I watched this playlist(Russian only), but only the first parts of the project structure and the last parts involving deploying the site to the server. And that's all, really. I figured out the rest either on my own, or with the help of Google, or the official documentation, or everyone's favorite, StackOverflow. Which I deeply regretted later, more than once.
You see, there's no denying it, I created the website, was able to deploy it myself, and even update it at first. But as time went on, the website became more complex, I added more and more features, fixed broken ones, or removed them entirely (because I couldn't fix them).
For example, I had comments on my site from the very beginning. It was implemented so poorly and bad that I soon removed it (July 9, 2024) (then brought it back (December 19, 2024), but with a more correct implementation). Or my own admin panel. I tried to create it three times. THREE TIMES. Each time, something went wrong, and they were terrible. (In the end, I settled on a ready-made solution - Django-Jet.)
Soon, maintaining this website became an almost impossible task. So I started reading books, watching YouTube tutorials, and browsing relevant websites.
I am writing this article for beginners who are just starting to build websites using Django, as well as for those who have some experience and success but still have room for improvement. While I want to save the time for the first ones and set them on the right path, for the second ones I want to convince them to read a little and/or check out tutorials on YouTube and/or other sites.
How is this article going to be structured?
Since I taught Django not only through books but also through YouTube playlists and other niche sites, this article will be divided into three sections:
- About books, reviews, and comparisons. I'll only be able to review the most popular (and those I've read ofcourse) books about Django website development. To provide the most specific recommendations on what's worth reading and who should read it, I'll divide readers by their experience level.
- About YouTube channels and their playlists. Here, in addition to providing links to relevant playlists, I'll also review specialized channels for learning Django.
- About niche sites. Sites whose authors offer excellent tutorials in interactive, text format.
How to choose for whom?
Each of us has our own level of knowledge and proficiency with the Django framework. This division is arbitrary and may not fully reflect a person's complexity and level of expertise, but for this article, I'll stick to it.
So, I'll divide readers into:
- Beginners – those with no experience in this area (Django/Python), but perhaps some experience in other areas of development, but not web development. For one reason or another, they want to learn the framework and start building their own websites.
- Professionals – those with previous experience in this area (Django/Python), or those with no experience with the Django framework but with experience working with other frameworks, such as FastAPI, Laravel, Flask, and others.
Where to start and for whom?
If you're a beginner, it's best to start with a format you enjoy. So, if you enjoy videos that let you see who's clicking where and what, then it's best to start with educational playlists on YouTube about Django. If you enjoy reading and revisiting what you've read from time to time, and value up-to-date information, then relevant websites will help. But if you want a comprehensive, comprehensive guide from A to Z, covering all the nuances and written by professionals, then Django books are your choice.
If you're a professional, documentation is your everything. But books are also helpful, especially those that offer new insights or demonstrate new approaches to solving certain problems. They'll help you find the right approach to solving a particular problem.
About Django's books
I'll start with books, as I consider them the best source for learning Django. In fact, each of the books below is self-contained, and by reading any one of them to the end, you'll have a finished project (or projects). Some even explain how to publish this "finished" project to servers.
Some of these books are quite outdated, but you can still find a lot of interesting information about Django or Python in them.
Criteria for comparing books
To be able to compare books, it's necessary to understand several key criteria by which the comparison will be made.
First, I'll provide a brief overview of each, after which, at the end of this chapter, I'll draw some conclusions and make recommendations for who should start with what.
The criteria will be as follows:
- Relevance. Is the literature up-to-date with current technology? New information is important for rapidly developing fields.
- Accuracy. How reliable is the information presented? Errors in technical texts can have serious consequences.
- Purpose. Is it a reference book, an operating manual, a textbook, or a general development book?
- Clarity and structure. Is the text easy to read and understand? Is the structure logical?
- Language. Is the language used precise, technically accurate, and without unnecessary complications?
Now, let's review each of these books.
Test-Driven Development with Python: Obey the Testing Goat: Using Django, Selenium, and JavaScript
Common information:
Author: Harry Percival
First publication: 2014y.
For whom: Beginners/Professionals
I'll start with my favorite book. Why my favorite? Judge for yourself: this book describes how to create a project from scratch to deployment to a production server. It also clearly explains how, when, and why to cover your site with tests, both functional and unit tests.
It explains in detail how to ensure that tests are part of the site deployment process when adding changes. This book is more about so-called Test Driven Development than about development itself.
Book's criterias:
- Relevance: Medium / High. Although the version of Django used is outdated, the core principles and methodology of TDD (Test-Driven Development) are absolutely timeless and remain the "gold standard" in the industry. Approaches to writing tests using unittest and Selenium are still relevant.
- Accuracy: Very High. Harry Percival is a renowned expert in the Python and Django community, co-founder of PythonAnywhere, and a frequent speaker at conferences. This book is considered the canonical guide to TDD in the Python/Django ecosystem.
- Purpose: Very High. This book is unique in its purpose. It is aimed at both Django beginners and TDD newcomers. Its main goal is to teach how to write code with tests in mind from the very first line. It doesn't "add" testing to Django, but rather uses TDD as a tool for designing and building Django applications.
- Clarity and Structure: Excellent. The book's structure is one large, comprehensive tutorial. The reader builds a web application (a "To-Do list") from scratch, following a strict "TDD rhythm." Each chapter presents a logical step in development (e.g., "Setting Up Unittest," "Testing the Model," "Testing Forms").
- Writing Style: Engaging and practical. The style is very easy, step-by-step, and motivating. The author uses humor and the memorable mantra "Obey the Testing Goat" to make the rigorous and disciplined TDD process engaging and understandable.
Key features and insights of the book:
- TDD as a design methodology: The book's key insight is that TDD isn't just "writing tests," but a discipline that defines the design of your code. You don't write code until you have a failing test that it's supposed to fix.
- Two Loops of TDD (Outer and Inner): The book does a brilliant job of teaching the "double loop" of TDD:
- Outer loop (Functional tests): First, a user-facing test is written (using Selenium) that describes the new feature and, naturally, fails.
- Inner loop(Unit tests): To make a functional test work, you start by writing unit tests for individual parts (models, views), write code to make them pass, refactor, and repeat until the functional test is "green".
- "Obey the Testing Goat": This mantra symbolizes the strict discipline of TDD and has become iconic in the community. It means that tests always come first and lead the development process.
- Starting with Selenium: Unlike many guides, Percival starts with Selenium, not unittest. This forces the reader to first think about what the user should see and do (the behavior), and only then about how to implement it (the internals).
User's reviews (taken from Amazon):
Django 5 By Example: Build Powerful and Reliable Python Web Applications from Scratch
Common information:
Author: Harry Percival
First publication: 2024y.
For whom: Beginners/Professionals
This book consists of six comprehensive examples of implementing various types of websites, namely:
- Blog
- Social Network
- Online Store
- Online Chat
- Django as an API for any Frontend
- E-Learning Platform
Everyone will find what they need to implement any given project. And, of course, you can read it in any order. Sometimes, creating a website takes several chapters, but even then, each chapter can be read independently.
However, it's also worth keeping in mind that the chapters become more complex as you delve deeper into the material. Therefore, beginners should start with the first chapter to get a feel for what's going on, and only then move on to the next chapters.
Book's criterias:
- Relevance: Very High. This book covers Django 5.0, making it one of the most relevant books on Django available today. It explores the framework's modern capabilities, including the innovations introduced in the latest versions.
- Accuracy: Very High. Antonio Mele is a respected author and experienced Django developer. This book is known for its technical accuracy and meticulously crafted examples. It is a reliable source for learning Django.
- Purpose: Very High. This is a project-oriented guide. Its goal is to teach Django hands-on, guiding the reader from start to finish through the creation of several full-fledged, complex web applications. It is ideal for those who already know the basics of Python and want to learn how to build real-world projects with Django.
- Clarity and Structure: The book's excellent structure is its main strength. Rather than being scattered across individual topics, it is built around six large projects.
- Presentation Style: Practical and step-by-step. The book's style is a detailed, step-by-step guide. The author literally "leads" the reader by the hand, showing them which line of code to add where. This is a very dense textbook, rich in code and practical instructions.
Key features and insights of the book:
- Project-based learning: This is a key feature. You don't learn isolated functions, but immediately see how they work together to solve a specific problem (for example, "how to create a shopping cart" or "how to implement a subscription system").
- Broadest Coverage: Thanks to a project-based approach, the book covers a vast stack of technologies essential to a modern Django developer. It goes far beyond the framework itself, including:
- Creating a REST API (using Django REST Framework).
- Implementing asynchronous tasks (using Celery).
- Using Redis for caching.
- Integrating payment systems.
- Creating recommender systems.
- Implementing chats (using Channels).
- Focus on "How," not "Why": Unlike "Two Scoops," this book focuses less on philosophy and more on practical recipes. It answers the question: "I want to implement feature X, what code do I need to do it?" Relevance: Using Django 5.0, it is one of the best resources for learning modern Django.
User's reviews (taken from Amazon):
Django Design Patterns and Best Practices: Industry-standard Web Development Techniques and Solutions Using Python
Common information:
Author: Arun Ravindran
First publication: 2015y.
For whom: Professionals
If you want to understand how to apply programming patterns to your Django application, you need to read this book. Also, if you're interested in how Django itself works and what patterns it uses, you need to read this book.
I liked the fact that you can easily build your own Django project from scratch. It's like a large tutorial of over 200 pages. It's a shame, of course, that it's "a bit" outdated now, and you won't be able to use all the features of modern Django.
In 2025, this book would have been recommended for beginners, but given its significant outdated status, it's now only useful for professionals who can highlight some of Django's early history and design.
Book's criterias:
- Relevance: Low. This book focuses on Django 1.7 and Python 3.4, both released in 2014. It is outdated in terms of versions. However, its core theme—design patterns—makes it conceptually very relevant. Design approaches such as Model Mixins, Service Objects, and User Profiles remain fundamental to writing clean and maintainable Django code.
- Accuracy: Very High. The author, Arun Ravindran, is an experienced developer (has been using Django since 2007) and a member of the Django Software Foundation. The book has been peer-reviewed by several experts. It demonstrates a deep understanding of both classic design patterns (GoF, Fowler) and their practical application in Django.
- Intended Use: Very High. This book is clearly positioned for developers who are already familiar with the basics of Django (having completed the basic tutorial) and want to deepen their understanding of the framework. Its goal is not just to show how, but to explain why, teaching readers formalized "best practices" and patterns for building maintainable software.
- Clarity and Structure: High. The book's structure logically follows the development lifecycle: from application design and models to working with views, templates, and forms, and then on to more complex topics such as working with legacy code, testing, security, and deployment. Each pattern is presented in a clear format: Problem, Solution, and Details.
- Presentation Style: Engaging and Pragmatic. The presentation style is one of the book's greatest strengths. The author uses an end-to-end "fictional story" about the creation of a social network for superheroes, "SuperBook." These inserts frame technical challenges in a clear, engaging context, making the reading less dry and more memorable.
Key features and insights of the book:
- Pattern Formalization: The book doesn't just offer advice; it introduces a pattern language. It connects classic patterns (MVC, Active Record, Template Method) to specific Django components and presents Django-specific patterns (e.g., Service Objects, Model Mixins, User Profiles, Context Enhancers) as formal solutions to recurring problems.
- Service Objects Pattern: The book proposes Service Objects as a solution to the problem of Fat Models. Logic not directly related to model state (e.g., interaction with external APIs or complex calculations) is extracted into separate "service" classes. This makes models cleaner, and the logic more testable and reusable.
- SuperBook Narrative Approach: Instead of isolated examples, the book uses the engaging story of the team creating SuperBook. This effectively demonstrates how technical decisions (such as choosing django-braces or customizing the admin panel) are made in the context of real-world requirements, deadlines, and even office politics.
- Pragmatism (From Design to Deployment): The book covers the entire lifecycle. It starts not with code, but with "Requirements Gathering" and "HTML Layouts," and includes important but often overlooked topics like "Dealing with Legacy Code" and "Security."
User's reviews (taken from Amazon):
Two Scoops of Django: Best Practices for Django 1.8
Common information:
Author: Audrey Roy
First publication: 2015y.
For whom: Professionals
Yes, I know the book Two Scoops of Django: Best Practices for Django 1.8 is quite outdated, given that it was written for Django version 1.8. Currently (at the time of this article's publication), Django 6.0 is available.
But it's also important to understand that the practices described in this book can be applied to modern versions as well. This book covers best practices from model design to writing tests and debugging Django applications.
Book's criterias:
- Relevance: Low. This book focuses on Django 1.8, which was released in 2015. Since then, the framework has undergone significant changes (e.g., the introduction of async, changes to the ORM, the evolution of Channels). Tips specific to Django 1.8 (e.g., some third-party packages or specific settings) are outdated. However, the core principles and best practices (project structure, the "Fat Models, Thin Views" philosophy, approaches to security, testing, and deployment) remain relevant and valuable today.
- Accuracy: Very High. This book was written by respected experts in the Django community and has been technically reviewed by key Django core developers, including Malcolm Treddinnick and Aymeric Augustin. For Django 1.8 and its time, this is the benchmark for accuracy.
- Intended Use: Very High. The authors clearly state that this is not a beginner's guide. This book is intended for developers who have already completed the official guide and want to learn how to build scalable, secure, and maintainable applications. Its goal is to document the "unwritten rules" and share real-world development experience.
- Clarity and Structure: The book's structure is very logical. It covers the entire development cycle, from environment setup to deployment and debugging. A key feature is its modularity—the authors note that each chapter can be read independently, making it an excellent reference.
- Presentation Style: The style is informal yet authoritative. The authors use clear analogies (such as ice cream) to explain concepts. A key element of the style is the use of "Don't Do This!" blocks, which clearly demonstrate common anti-patterns and help avoid them. The book is opinionated, but the authors are open about it.
Key features and insights of the book:
- The central philosophy: "Fat Models, Thin Views." This is perhaps the book's most important insight. The authors insist that business logic should be encapsulated in models (Fat Models) or extracted into separate utilities, while views (Thin Views) should be as lean as possible, responsible only for processing the HTTP request and response.
- Stupid Templates: Continuing with this core philosophy, templates should contain a minimum of logic. Any complex data processing or database queries should occur in Python code (in a view or model), not in a template.
- Standardizing Project Structure: The book actively promotes a standardized, scalable project structure, which later formed the basis of the popular cookiecutter-django pattern. This includes separating settings for different environments (dev, prod) and placing them in a separate directory.
- Settings Security: The authors were among the first to widely advocate storing secret keys (SECRET_KEY, database passwords, API keys) outside of version control, using environment variables or special secrets files.
- Avoiding Framework "Magic": The book warns against overusing those parts of Django that make code implicit and difficult to debug. In particular, it is recommended to avoid overusing signals and not placing view logic inside URLconfs.
User's reviews (taken from Amazon):
The Temple of Django Database Performance
Common information:
Author: Andrew Brookins
First publication: 2019y.
For whom: Professionals
This advanced guide for Django developers focuses exclusively on database performance optimization. It teaches you to go beyond simple ORM usage and deeply analyze how queries are executed at the DBMS level, how to use EXPLAIN ANALYZE to troubleshoot problems, and how to apply advanced techniques (such as complex indexes, denormalization, and raw SQL) to build high-performance applications.
Book's criterias:
- Relevance: High. While the Django ORM syntax continues to evolve, the fundamental principles of database performance (indexing, query plans, denormalization, locking) are practically timeless. The profiling and EXPLAIN ANALYZE techniques taught in this book remain absolutely relevant and are essential skills for any senior Django developer.
- Accuracy: Expert. This is one of the most technically accurate and in-depth books on Django. Written by an expert for experts (or those who want to become one), it delves into how ORM is translated into SQL and how that SQL is executed by PostgreSQL with surgical precision.
- Intended Use: Highly Specialized / Advanced. The purpose of this book is crystal clear: to teach experienced Django developers how to diagnose and fix database performance bottlenecks. This is not a book for beginners. It is intended for those who have already built an application and are experiencing slowdowns.
- Clarity and Structure: High. The book's structure is logical and well-thought-out. It guides the reader through the "temple" of knowledge: from the basics (performance measurement) to the "inner sanctum" (advanced indexing methods, denormalization, materialized views).
- Presentation Style: Technical, Academic, Dense. The style is very dense, rich in technical detail. It requires high concentration and basic knowledge of SQL and database management systems (in particular, PostgreSQL, which is the focus of the book). This is not a light read, but a serious textbook.
Key features and insights of the book:
- "Misery is Optional": This is the book's leitmotif. The author argues that poor performance isn't a necessary evil when using ORMs, but rather the result of a lack of understanding of how databases work.
- You Must Read EXPLAIN ANALYZE: The main tool taught in the book is EXPLAIN ANALYZE (for PostgreSQL). The author insists that it's impossible to optimize queries without learning how to read their execution plans.
- Think in SQL: To master the Django ORM, you must understand the SQL it will be translated into. The book teaches you to "think in SQL," even when writing in Python.
- Indexing Mastery: The book goes far beyond simply db_index=True. It thoroughly examines when and why to use Partial Indexes, multi-column indexes, GIN/GiST indexes, and other advanced PostgreSQL features. Pragmatism over dogma: The book pragmatically shows when to "let go" of the ORM and use denormalization, materialized views, or raw SQL (Raw()) to achieve the performance you need.
User's reviews (taken from Amazon):
Some general conclusions and book recommendations
I recommend starting and finishing with Django 5 by Examples. For both beginners and experts. Why? The beauty of this book is that the difficulty gradually increases, and even a beginner can read and master the first chapters. As a result, you not only have the theory in your head, but also a working website.
Continuing with the topic of the first book, although it is almost comprehensive, it doesn't cover the most important topic: testing. Therefore, after this book, you can immediately start reading Test Driven Design with Python. There, you'll learn how and why to write tests.
You can read the rest in any order. That's how much I've read about Django—not a huge amount, but enough to build websites. I'm sure you might have other books you've read that you think are also worth reading. If so, let me know in the comments; I'll definitely check them out.
About YouTube playlists
Even though I first learned Django on YouTube, I'm not a big fan of video tutorials. Of course, that's purely my preference, and yours may be completely different.
But what I'm getting at is that after scrolling through my feed a bit, I was surprised by how few full-fledged "guides" (or tutorials) YouTube offers. I barely had time to move on to another page before they ran out. On the Russian segment, it was even earlier. But that's just a simple observation.
Recommended playlists for beginners
Yes, it's true that there's nothing there for beginners, or even more experienced developers. It's just basic, general information that can be found on the official website, Googled, or even asked by the AI. But let's see what's available.
I already mentioned this author's playlist at the beginning, which was my introduction to Django. But as I understand it, he's re-released his playlist for the new (no anymore) Django version 4. I honestly haven't watched the re-released version of the playlist, but I can definitely recommend this playlist and the author as an excellent starting point for learning the Django framework version 4.
But there's a catch. This playlist doesn't cover one of the most important steps: deploying to a live server. This step can be explored in his previous playlist on Django 3. Will there be a sequel? I doubt it. The channel has very few views, and the relevance of Django version 4 is declining every month.
This playlist covers the bare minimum, but nothing more. The Django playlist has been abandoned for several years now, and I don't think the author will be able to complete it.
I also liked this guy; he explains everything very beautifully and clearly. And most importantly, the manual is quite up-to-date.
That's basically it. Of course, there are plenty of useful videos on YouTube. Some are quite specific and niche. There are, as I showed, playlists for beginners with basic information. But there simply aren't any that cover all of Django.
About Django websites
If good playlists are scarce, then websites with a complete and comprehensive program are even rarer. And I'm talking about websites that might be useful to beginners. Professionals are limited to just documentation and a couple of books.
But websites have one undeniable advantage over video tutorials or books: they're always up-to-date—at a minimum, the documentation is. So, in ten years, unless new books, video tutorials, or authors who love Django so much that they're willing to spend countless hours creating all of the above appear, we'll always have a website with official documentation.
Where should a beginner start?
But let's not jump into the future too far. It's 2025 now, and if you've decided to learn Django from websites, I recommend starting with this website:
Listen, I know this is a girls' site, but the tutorial is very well structured and written. So it's worth using, especially considering they cover creating a Django site from start to publishing to the server. Here's the official tutorial.
After you finish the girls' tutorial, you can learn more about creating a Django app/site on the official website.
You can review the official documentation and pinpoint any topics where you have gaps in your knowledge or understanding. You can also check out the tutorial on creating Django applications, which will help you understand some of the features and nuances of creating portable applications.
And the last website I can recommend is from the Mozilla Group. They document existing web technologies, projects, and frameworks.
If you value detail and explanations of every possible minutia when creating your first or perhaps second app—that is, you're a real pedant—then you should definitely start with this tutorial. Each stage of website creation is a multi-meter canvas, with detailed explanations and examples.
The conclusion or hope is that I was able to convince someone to read a couple of books, watch a couple of playlists or explore a few websites
That's basically all I wanted to share with you. And it should help you avoid the mistakes I made back then, and as a result, save you a ton of time. I know, it doesn't seem like a time-saver to you now. Just reading the book Django 5 by Examples is worth it. You'll have to spend weeks or even months to master it thoroughly. But when it comes time to rewrite the site's backend, you'll remember me and that book you were too lazy to read.
Although, maybe it's for the best. For example, for a long time I couldn't grasp the concept of testing in programming. Like, why write more code? I'm already short on time, should I waste it on tests? But when your site breaks again, and it seems there's nothing to break, and you've been searching for an error on the "production" server for three days and finally manage to find it, you'll realize: I wish I'd written those damn tests.
In any case, I hope this article was interesting and informative. And I was able to answer the question: "How and where to start building websites with Django?"
