MVC Architecture (Introduction)

Introduction

Up to this point, most of the scripts you have written have mixed everything together in one place: database queries, business logic, and HTML output, all in a single .php file. That works fine for small pages, but as an application grows to dozens or hundreds of files, that mixing becomes a serious problem — a change to how data is displayed can accidentally break the logic that fetches it, and vice versa.

MVC (Model-View-Controller) is a design pattern that solves this by splitting an application into three clearly separated responsibilities. It is not a PHP-specific idea — it is used across many languages and frameworks — but it is especially central to how modern PHP applications, including Laravel and Symfony, are structured.

The Problem MVC Solves

Imagine a single PHP file that connects to the database, runs a query, applies business rules, and then prints HTML — all in one script. It works, but it has real costs as the project grows.

MVC addresses this by giving each concern its own home, so each piece can change independently of the others.

What is MVC?

MVC divides an application into three parts, each with one clear job.

How a Request Flows Through MVC

When a visitor requests a page, the request does not go straight to a View. It is routed to a Controller first, which orchestrates everything else.

A Tiny Folder Structure Example

MVC is usually reflected directly in how project files are organized. A minimal example might look like this.

app/
├── Controllers/
│   └── ProductController.php
├── Models/
│   └── Product.php
└── Views/
    └── product-details.php

Each folder maps directly to one of the three responsibilities: Controllers/ handles requests, Models/ handles data and logic, and Views/ handles what gets displayed.

A Simplified MVC Example

This is a deliberately simplified illustration — real frameworks add routing, dependency injection, and more structure — but the core idea is exactly this separation.

<?php

class Product
{
    public static function find(int $id): ?array
    {
        $products = [
            5 => ['id' => 5, 'name' => 'Wireless Mouse', 'price' => 19.99],
        ];

        return $products[$id] ?? null;
    }
}

<?php

require __DIR__ . '/../Models/Product.php';

class ProductController
{
    public function show(int $id): void
    {
        $product = Product::find($id);

        if ($product === null) {
            echo "Product not found.";
            return;
        }

        require __DIR__ . '/../Views/product-details.php';
    }
}

<h1><?= htmlspecialchars($product['name']) ?></h1>
<p>Price: $<?= number_format($product['price'], 2) ?></p>

<?php

require __DIR__ . '/Controllers/ProductController.php';

$controller = new ProductController();
$controller->show(5);

Wireless Mouse
Price: $19.99

Notice that Product knows nothing about HTML, product-details.php knows nothing about arrays coming from a database, and ProductController is the only piece that talks to both.

MVC in Real Frameworks

The example above is intentionally tiny — you would not hand-write require statements like this in a real production application. Popular PHP frameworks build entire, mature systems around the MVC pattern, adding routing, request objects, templating engines, and much more.

You do not need to learn a framework to understand MVC — the concept stands on its own. But recognizing this pattern now means that when you do pick up Laravel or Symfony later, the folder structure and flow will already feel familiar.

Common Mistakes

Best Practices

Frequently Asked Questions

Key Takeaways

Summary

MVC is one of the most important organizing ideas in web development. By keeping data (Model), presentation (View), and request handling (Controller) separate, applications stay easier to understand, test, and extend as they grow far beyond a handful of files.

In this lesson, you learned what each part of MVC means, how a request flows through all three, and how this same pattern underlies frameworks like Laravel and Symfony. Next, you will look at security best practices every PHP application should follow.