What is the MVT architecture?

Question

Accepted Answer

Django follows the **MVT (Model-View-Template)** architecture — its variation on the classic MVC pattern. It separates an application into three layers: **Models** (data), **Views** (logic), and **Templates** (presentation). Understanding the layers clarifies where each piece of code belongs. ## The three layers ```text Model → the DATA layer: defines structure & talks to the database (the ORM) View → the LOGIC layer: processes requests, fetches data, returns responses Template → the PRESENTATION layer: HTML with placeholders for dynamic data ``` ## How they work together (the request flow) ```text Request → URLconf (routing) → VIEW → queries MODELS → renders TEMPLATE → Response ``` ```python # MODEL — defines the data (models.py) class Article(models.Model): title = models.CharField(max_length=200) body = models.TextField() # VIEW — the logic: fetch data, pass to a template (views.py) def article_list(request): articles = Article.objects.all() # query the MODEL return render(request, "articles.html", {"articles": articles}) # render a TEMPLATE ``` ```html {% for article in articles %}

{% endfor %} ``` The view ties it together: it receives the request, queries the models for data, and renders a template with that data to produce the response. ## MVT vs MVC ```text Classic MVC: Model — View — Controller Django MVT: Model — Template — View The mapping (a common point of confusion): Django's VIEW ≈ MVC's CONTROLLER (the logic that handles requests) Django's TEMPLATE ≈ MVC's VIEW (the presentation) Model is the same in both → Django says the framework itself acts as the "controller" (URL routing/dispatch). ``` The naming differs from MVC: Django's **View** plays the role of MVC's *Controller* (request-handling logic), and Django's **Template** plays MVC's *View* (presentation). The framework's routing handles dispatch. ## Why this separation matters ```text ✓ Separation of concerns — data, logic, and presentation are independent ✓ Maintainability — change the template without touching logic, etc. ✓ Reusability & testability — test views independently, reuse models/templates ``` ## Why it matters The MVT architecture is the fundamental structural pattern of every Django application — understanding it tells you **where each piece of code belongs** (data definitions in models, request-handling logic in views, HTML presentation in templates), which is essential for organizing any Django project correctly. The separation of concerns it enforces makes applications maintainable (change presentation without touching logic), testable (test views and models independently), and reusable. Equally important is understanding the **MVT-vs-MVC mapping** — a frequent source of confusion — where Django's "View" is actually the controller-equivalent (the logic) and Django's "Template" is the view-equivalent (the presentation); knowing this clears up the naming and helps developers coming from MVC frameworks. The request flow (URL routing → view → models → template → response) is the mental model for how every Django request is processed, making MVT foundational, must-know knowledge that underpins how you structure and reason about all Django code.