This professional beginner’s guide explains Laravel’s folder structure and MVC (Model-View-Controller) architecture step by step. With practical examples, annotated code snippets, and clear explanations, you’ll learn how Laravel organizes its files and how MVC makes modern PHP development simple and powerful.
When you first open a fresh Laravel project, the folder structure might look intimidating. You’ll see directories like app, routes, resources, and many more. At the same time, you’ll hear terms like “MVC architecture” and wonder how they fit together.
In this guide, we’ll break it all down in a simple and engaging way. Think of this as a tutorial script that walks you through Laravel’s structure, explaining how MVC works in practice, and giving you step-by-step examples along the way.
Table of contents [Show]
Laravel’s folder structure is carefully designed to follow best practices and make your application maintainable. Knowing where your code belongs saves time, reduces bugs, and helps you work like a professional developer.
Let’s look at the top-level folders you’ll see in a new Laravel project.
| Folder | Purpose |
|---|---|
app/ | Main application logic (models, controllers, etc.) |
bootstrap/ | Bootstraps the framework and loads configuration |
config/ | Holds all configuration files |
database/ | Migrations, seeders, and factories |
public/ | Publicly accessible files (index.php, CSS, JS, images) |
resources/ | Views (Blade templates), language files, and frontend assets |
routes/ | All route definitions |
storage/ | Logs, cache, and file uploads |
tests/ | Automated tests |
vendor/ | Composer dependencies |
app/ FolderThis is the heart of your Laravel application. Inside app/, you’ll find subfolders like Http/, Models/, and Console/.
Http/: Controllers, middleware, and requests live here.Models/: Your Eloquent models (representing database tables).Console/: Custom Artisan commands.routes/ FolderRoutes define how your application responds to different URLs. Laravel provides web.php for web routes and api.php for API routes.
// routes/web.php
use Illuminate\Support\Facades\Route;
Route::get('/hello', function () {
return "Hello from Laravel!";
});
resources/ FolderThis is where your frontend lives—Blade views, JavaScript, and styles.
<!-- resources/views/welcome.blade.php -->
<!DOCTYPE html>
<html>
<head>
<title>Welcome</title>
</head>
<body>
<h1>{{ $message }}</h1>
</body>
</html>database/ FolderLaravel migrations and seeders live here, allowing you to manage database schema and test data.
php artisan make:migration create_posts_table --create=posts
// database/migrations/xxxx_xx_xx_create_posts_table.php
public function up()
{
Schema::create('posts', function (Blueprint $table) {
$table->id();
$table->string('title');
$table->text('content');
$table->timestamps();
});
}
public/ FolderThis is the only folder accessible to the outside world. The entry point index.php lives here and loads the entire Laravel application.
config/ FolderAll your configuration lives here, like database credentials (config/database.php) or mail settings (config/mail.php).
MVC stands for Model-View-Controller. Laravel is built around this design pattern, which helps separate concerns and keep your application organized.
php artisan make:model Post -mThis command creates a Post model and a migration file.
// database/migrations/xxxx_xx_xx_create_posts_table.php
public function up()
{
Schema::create('posts', function (Blueprint $table) {
$table->id();
$table->string('title');
$table->text('body');
$table->timestamps();
});
}
php artisan make:controller PostController
// app/Http/Controllers/PostController.php
namespace App\Http\Controllers;
use App\Models\Post;
class PostController extends Controller
{
public function index()
{
$posts = Post::all();
return view('posts.index', compact('posts'));
}
}
// routes/web.php
use App\Http\Controllers\PostController;
Route::get('/posts', [PostController::class, 'index']);
<!-- resources/views/posts/index.blade.php -->
<!DOCTYPE html>
<html>
<head>
<title>All Posts</title>
</head>
<body>
<h1>Posts</h1>
<ul>
@foreach($posts as $post)
<li>{{ $post->title }} - {{ $post->body }}</li>
@endforeach
</ul>
</body>
</html>Here’s how it all connects:
/posts.PostController@index.Post model.View.app/Models directory and not using Eloquent models.By following the MVC pattern and understanding the folder structure, you can avoid these pitfalls.
Laravel’s folder structure and MVC architecture are designed to make your applications clean, maintainable, and professional. Once you understand where each piece of code belongs and how MVC ties it together, you’ll find development more enjoyable and efficient.
Keep practicing, explore each folder, and soon Laravel’s structure will feel second nature!
This article is a comprehensive tutorial on using the Prohibited Validation Rules in Laravel. You will learn how to apply prohibited, prohibited_if, and prohibited_unless with clear explanations, real-life scenarios, and code examples. This guide is perfect for developers who want to master advanced validation techniques in Laravel applications.
This detailed tutorial explores request validation in Laravel controllers. You’ll learn multiple techniques—basic controller validation, using form request classes, custom rules, conditional validation, error handling, localization, and best practices. With practical examples, code snippets, and structured explanations, this article is designed for beginners to advance learner.
This guide teaches you how to deploy Laravel applications to production servers. From preparing your environment and configuring Nginx or Apache, to database migrations, caching, performance optimization, CI/CD pipelines, and security practices—this article covers everything step by step.It’s suitable for both beginners and advanced developers who want to ship stable, secure & scalable app.
