roadmap
- 01
- 02
- 03
- 04
- 05
- 06
- 07
- 08
Prepare for Django interviews on the current framework: models and the ORM, views, forms, the admin and auth. Covers REST APIs with DRF and Ninja, caching, async and Celery, testing and deployment.
689 of 689 questions in your plan: 0 known, 0 in progress, 0 due, 0 skipped, 689 new. 0 cut, outside your plan.
Django questions usually arrive inside a Python backend loop rather than as a separate round: a take-home brief to build a small app or API, the technical conversation after a Python coding screen and, from middle level up, a design round where the framework's defaults become constraints. Teams that run Django in production can keep that conversation on the framework throughout, and it starts from code put in front of you: a template reading `book.author.name` in a loop, a `post_save` receiver that never fires because the code called `QuerySet.update()`, a Celery task that cannot find the row it was handed because the transaction creating it had not committed, a `LoginRequiredMixin` listed to the right of the view it was meant to guard. What changes with level is where the answer stops. Naming the fix clears the junior bar: `select_related`, `transaction.on_commit`, the mixin moved left. A senior candidate also says how the problem would be found on a page they did not write, by pinning the query count with `assertNumQueries` or reading the SQL the debug toolbar shows, and what changes once the data is live: two requests racing for one row, which `select_for_update` settles only inside `atomic`, or a migration dropping a column the previous release still reads while both run during a deploy.
Request handling comes before data here. [The path a request takes](/topics/be-django-project-mtv) to a view, how [the URL dispatcher](/topics/be-django-views-routing) picks and names that view, and what a view must hand back all come before a single model, so later modules have a route to hang on. The stretch ends on class-based views, where [mixins and the method resolution order](/topics/be-django-cbv-mixins) make behavior depend on the order of a class's bases. Templates & Forms covers both directions of a page: output, with [autoescaping](/topics/be-django-forms-templates-autoescape) deciding what reaches the browser as markup, and input, through a cleaning flow that ends in the [ModelForm](/topics/be-django-forms-modelforms), the bridge into the data layer. That layer takes three steps, each built on the last: model classes, the QuerySet API, then [query tuning](/topics/be-django-orm-performance) at once, because N+1 selects are a consequence of the laziness the API is built on. Databases & Migrations goes below the ORM to what it cannot promise alone: savepoints, [commit hooks](/topics/be-django-db-commit-hooks) that hold a side effect until its data is durable, row locks, and schema changes [the release still running can live with](/topics/be-django-migrations-zero-downtime). Identity follows once models and forms exist. The [admin site](/topics/be-django-admin-drf) comes first because it is largely those two reused; then accounts, with the [custom user model](/topics/be-django-auth-middleware-account-models) best settled before the first migration, and permissions down to [checks on a single object](/topics/be-django-permissions-object-level), which the default backend does not perform. Only then does the plan open the pipeline that has been filling in `request.user` and `request.session` all along. [Middleware](/topics/be-django-middleware) sits this far down because ordering rules such as sessions before authentication read as obvious once you know what each layer supplies, and most of the built-in protections closing the module are middleware themselves. The REST APIs module rebuilds that handling for JSON: [Django REST Framework](/topics/be-drf) wraps a view in its own authentication, permission and throttling steps, with serializers that echo forms, and Django Ninja follows as the typed alternative on Pydantic. The next stretch is about time, from cached responses through the [sync and async boundary](/topics/be-django-async-bridging) to work that leaves the request entirely, ending in [Celery](/topics/be-celery) as a system of its own. After the short Locales & Diagnostics module, the plan closes where a project leaves the developer's machine: tests, static files the development server stops serving once `DEBUG` is off, and [running in production](/topics/be-django-deployment).
What Django is in the posting decides how much of the plan to take. Where it is the team's own stack and the date is a week or two off, the hours belong to Models & the ORM and Databases & Migrations, with each answer checked against the queries it would send; narrowing level to the seniority on the offer and raising importance to must know keeps those two modules short enough to finish. Months out, the debug toolbar is worth more than another read-through: keep one small app open beside the plan, work the modules in sequence after switching study order to by topics, and look at the SQL behind every ORM question you answer. Engineers who have only built APIs with DRF tend to skip Templates & Forms, at a cost: a form's `clean_<field>()` then `clean()` has the same shape as a serializer's `validate_<field>()` then `validate()`, and each explains the other. Senior candidates should not hurry past the first module either, because [release cadence and upgrades](/topics/be-django-project-releases) sits there, and moving a live project across releases is a common principal-level conversation. The plan assumes Python and teaches none of the language: generators, decorators as a language feature, descriptors and the GIL are left to the [Python roadmap](/roadmaps/python), and Django loops usually test them in the coding screen before the framework comes up.
Django questions usually arrive inside a Python backend loop rather than as a separate round: a take-home brief to build a small app or API, the technical conversation after a Python coding screen and, from middle level up, a design round where the framework's defaults become constraints. Teams that run Django in production can keep that conversation on the framework throughout, and it starts from code put in front of you: a template reading book.author.name in a loop, a post_save receiver that never fires because the code called QuerySet.update(), a Celery task that cannot find the row it was handed because the transaction creating it had not committed, a LoginRequiredMixin listed to the right of the view it was meant to guard.
What changes with level is where the answer stops. Naming the fix clears the junior bar: select_related, transaction.on_commit, the mixin moved left. A senior candidate also says how the problem would be found on a page they did not write, by pinning the query count with assertNumQueries or reading the SQL the debug toolbar shows, and what changes once the data is live: two requests racing for one row, which select_for_update settles only inside atomic, or a migration dropping a column the previous release still reads while both run during a deploy.
Request handling comes before data here. The path a request takes to a view, how the URL dispatcher picks and names that view, and what a view must hand back all come before a single model, so later modules have a route to hang on. The stretch ends on class-based views, where mixins and the method resolution order make behavior depend on the order of a class's bases.
Templates & Forms covers both directions of a page: output, with autoescaping deciding what reaches the browser as markup, and input, through a cleaning flow that ends in the ModelForm, the bridge into the data layer. That layer takes three steps, each built on the last: model classes, the QuerySet API, then query tuning at once, because N+1 selects are a consequence of the laziness the API is built on. Databases & Migrations goes below the ORM to what it cannot promise alone: savepoints, commit hooks that hold a side effect until its data is durable, row locks, and schema changes the release still running can live with.
Identity follows once models and forms exist. The admin site comes first because it is largely those two reused; then accounts, with the custom user model best settled before the first migration, and permissions down to checks on a single object, which the default backend does not perform. Only then does the plan open the pipeline that has been filling in request.user and request.session all along. Middleware sits this far down because ordering rules such as sessions before authentication read as obvious once you know what each layer supplies, and most of the built-in protections closing the module are middleware themselves.
The REST APIs module rebuilds that handling for JSON: Django REST Framework wraps a view in its own authentication, permission and throttling steps, with serializers that echo forms, and Django Ninja follows as the typed alternative on Pydantic. The next stretch is about time, from cached responses through the sync and async boundary to work that leaves the request entirely, ending in Celery as a system of its own. After the short Locales & Diagnostics module, the plan closes where a project leaves the developer's machine: tests, static files the development server stops serving once DEBUG is off, and running in production.
What Django is in the posting decides how much of the plan to take. Where it is the team's own stack and the date is a week or two off, the hours belong to Models & the ORM and Databases & Migrations, with each answer checked against the queries it would send; narrowing level to the seniority on the offer and raising importance to must know keeps those two modules short enough to finish. Months out, the debug toolbar is worth more than another read-through: keep one small app open beside the plan, work the modules in sequence after switching study order to by topics, and look at the SQL behind every ORM question you answer.
Engineers who have only built APIs with DRF tend to skip Templates & Forms, at a cost: a form's clean_<field>() then clean() has the same shape as a serializer's validate_<field>() then validate(), and each explains the other. Senior candidates should not hurry past the first module either, because release cadence and upgrades sits there, and moving a live project across releases is a common principal-level conversation.
The plan assumes Python and teaches none of the language: generators, decorators as a language feature, descriptors and the GIL are left to the Python roadmap, and Django loops usually test them in the coding screen before the framework comes up.