Getting Started with Laravel

Reviewed & published by Brayan K

Laravel is the most popular PHP framework in the world. In this lesson you'll install it with Composer, understand its MVC structure, declare routes, write controllers, render Blade templates, model your data with Eloquent, and drive it all from the Artisan command line.

Part of the free PHP course at LearnCodingFast — hands-on lessons with worked examples and the output they print, plus practice exercises and a quick quiz.

What You'll Learn in This Lesson

• Install a new Laravel app with Composer and run it
• Understand the MVC structure and where code lives
• Declare routes with Route::get and route groups
• Write controllers and validate incoming requests
• Render dynamic pages with Blade templates
• Model and query data with the Eloquent ORM

1️⃣ Installing Laravel with Composer

Laravel is distributed as a Composer package, so creating a new app is a single command. composer create-project laravel/laravel blog downloads the framework, installs all its dependencies, and scaffolds a complete project. From there, php artisan serve launches a local development server. Artisan — Laravel's command-line tool — is how you'll generate code, run migrations, and manage the app throughout the lesson.

# Laravel ships as a Composer package, so you install it with Composer.
# This one command downloads the framework and scaffolds a whole app.

composer create-project laravel/laravel blog   # create a project named "blog"

cd blog                 # move into the new project directory
php artisan serve       # start the built-in dev server on http://127.0.0.1:8000

# "artisan" is Laravel's command-line tool. You'll use it constantly:
#   php artisan list        -> show every available command
#   php artisan make:model  -> generate code (models, controllers, migrations...)
#   php artisan migrate     -> run your database migrations

After scaffolding, the project follows a fixed layout: routes live in routes/web.php, controllers in app/Http/Controllers, models in app/Models, and views in resources/views. Knowing where each kind of file belongs is half of learning a framework.

2️⃣ Routing: Mapping URLs to Actions

A route connects an HTTP method and URL to the code that should run. You declare them in routes/web.php with calls like Route::get, Route::post, and friends. An action can be an inline closure or — better for real logic — a controller method. Routes can take URL parameters like and be wrapped in middleware groups so, for example, every route in a group requires a logged-in user.

<?php
// routes/web.php — every URL your app answers is declared here.
// Each route maps an HTTP method + URL to an action (a closure or controller).

use Illuminate\Support\Facades\Route;
use App\Http\Controllers\PostController;

// A simple closure route: GET / returns a Blade view called "welcome"
Route::get('/', function () {
    return view('welcome');               // renders resources/views/welcome.blade.php
});

// A route with a URL parameter ({id}) handled by a controller method
Route::get('/posts/{id}', [PostController::class, 'show']);

// Group of routes that all require a logged-in user (auth middleware)
Route::middleware('auth')->group(function () {
    Route::get('/dashboard', [PostController::class, 'index']);
    Route::post('/posts', [PostController::class, 'store']);   // create a post
});
?>

Run php artisan route:list any time to see every route your app answers and which action handles it — invaluable when a project grows large.

3️⃣ Controllers: The Logic Layer

A controller groups the actions for one resource — listing, showing, creating, updating. Generate one with php artisan make:controller PostController. Each public method handles a route: it fetches data (usually via Eloquent), maybe validates input, and returns a view or a redirect. Crucially, a controller should never trust raw input — call $request->validate() first so the rest of the method only runs on clean data.

<?php
// app/Http/Controllers/PostController.php
// A controller groups the logic for one resource. Generate it with:
//   php artisan make:controller PostController

namespace App\Http\Controllers;

use App\Models\Post;
use Illuminate\Http\Request;

class PostController extends Controller
{
    // Show a list of posts. The view receives the data via compact().
    public function index()
    {
        $posts = Post::latest()->get();        // Eloquent: all posts, newest first
        return view('posts.index', compact('posts'));
    }

    // Show one post by id. findOrFail() auto-throws a 404 if it's missing.
    public function show(int $id)
    {
        $post = Post::findOrFail($id);
        return view('posts.show', compact('post'));
    }

    // Create a post from form input — but validate it FIRST.
    public function store(Request $request)
    {
        $data = $request->validate([
            'title' => 'required|max:255',     // must be present, max 255 chars
            'body'  => 'required',
        ]);
        Post::create($data);                   // mass-assign the validated fields
        return redirect('/dashboard');
    }
}
?>

Notice findOrFail(): it returns the record or automatically throws a 404 if the id doesn't exist, so you don't have to write that check by hand. This kind of sensible default is everywhere in Laravel.

4️⃣ Blade Templates: The View Layer

Blade is Laravel's templating engine. Files end in .blade.php and compile down to plain PHP. Blade adds clean directives — @if, @foreach, @extends for layout inheritance — and the syntax that echoes a value and escapes it, stopping XSS automatically. That makes views readable while keeping output safe by default.

{{-- resources/views/posts/index.blade.php --}}
{{-- Blade is Laravel's template engine. Files end in .blade.php. --}}

@extends('layouts.app')          {{-- inherit a shared parent layout --}}

@section('content')              {{-- fill the parent's "content" slot --}}
    <h1>Latest Posts</h1>

    @forelse ($posts as $post)    {{-- loop, with a built-in "empty" case --}}
        <article>
            {{-- {{ }} echoes AND escapes output, stopping XSS automatically --}}
            <h2>{{ $post->title }}</h2>
            <p>{{ $post->body }}</p>
        </article>
    @empty
        <p>No posts yet.</p>
    @endforelse
@endsection

The @extends / @section pair lets every page share one parent layout (header, nav, footer) and only fill in its own content — the templating equivalent of inheritance.

5️⃣ Eloquent ORM: The Model Layer

Eloquent is Laravel's object-relational mapper. Each model class maps to a database table, and table rows become objects you can read, change, and save — no hand-written SQL. You define the table's structure in a migration (run with php artisan migrate), set $fillable for safe mass-assignment, and declare relationships like belongsTo and hasMany as methods so related records are just a property away.

<?php
// app/Models/Post.php — an Eloquent MODEL maps to a database table.
// Generate the model AND its migration together with:
//   php artisan make:model Post -m

namespace App\Models;

use Illuminate\Database\Eloquent\Model;

class Post extends Model
{
    // Columns that are safe to mass-assign via create()/update()
    protected $fillable = ['title', 'body', 'user_id'];

    // Relationship: a Post belongs to one User (its author)
    public function user()
    {
        return $this->belongsTo(User::class);
    }
}

// --- Using the model anywhere in your app ---
$post = Post::create(['title' => 'Hi', 'body' => 'Body', 'user_id' => 1]);
$post = Post::find(1);                 // SELECT * FROM posts WHERE id = 1
$author = $post->user->name;           // follows the belongsTo relationship
$recent = Post::where('user_id', 1)->latest()->take(5)->get();
?>

Now you try the two core skills — declaring a route and validating input. Fill in each ___ using the 👉 hint, then run the matching artisan command and check the Output panel.

<?php
// 🎯 YOUR TURN — register a route and point it at a controller method.
// Fill in each blank marked ___ , then run "php artisan route:list".

use Illuminate\Support\Facades\Route;
use App\Http\Controllers\PostController;

// 1) Answer GET requests to /about with a closure that returns a view
Route::___('/about', function () {     // 👉 the HTTP verb: get
    return view('about');
});

// 2) Send GET /posts to PostController's index method
Route::get('/posts', [PostController::class, '___']);   // 👉 the method name: index

// ✅ route:list should then show both routes.
?>

One more. A controller must validate before it saves. Add the validation call and the missing rule.

<?php
// 🎯 YOUR TURN — validate form input before saving it.
// A controller must never trust raw input. Add the rules, then save.

public function store(Request $request)
{
    // 1) Require a title (max 255) and a body
    $data = $request->___([            // 👉 the method that validates: validate
        'title' => 'required|max:255',
        'body'  => '___',              // 👉 make body required too: required
    ]);

    // 2) Create the post from the validated data
    Post::create($data);
    return redirect('/posts');
}

// ✅ Submitting an empty title redirects back with an error,
//    and store() never runs the create() line.
?>

Common Errors (and the fix)

• "Class not found" for a controller — your route references a controller you forgot to use, or the class name and file don't match. Add the use App\Http\Controllers\PostController; import and run composer dump-autoload.
• "Add [title] to fillable property" (MassAssignmentException) — Eloquent blocks mass-assigning columns you haven't whitelisted. List them in protected $fillable = ['title', 'body']; on the model.
• "Base table or view not found" — you queried a model before running its migration. Run php artisan migrate (and check your .env database settings).
• "419 Page Expired" on a form POST — Laravel's CSRF protection rejected the request because the form is missing a token. Add @csrf inside the Blade <form>.
• View renders as literal text — the file isn't named .blade.php, so Blade never compiles it. Rename it and return it with view('posts.show').

Pro Tips

• 💡 Generate with -m. php artisan make:model Post -mcr scaffolds the model, migration, and a resource controller in one go.
• 💡 Eager-load to avoid N+1. Use Post::with('user')->get() so related users load in one query instead of one per post.
• 💡 Use Tinker. php artisan tinker opens a REPL where you can run Post::count() and test Eloquent live.

📋 Quick Reference — Laravel Basics

Mini-Challenge: A Tasks Feature

No code is filled in this time — just a brief and an outline. Build it yourself in a real Laravel project: generate the model and migration, wire up routes, list tasks in a Blade view, and add a validated create action. This is the full MVC loop you'll use in every Laravel app.

<?php
// 🎯 MINI-CHALLENGE: A tiny "tasks" feature, end to end.
// No code is filled in — work from the steps below.
//
// 1. Generate the pieces with artisan:
//      php artisan make:model Task -m            (model + migration)
//      php artisan make:controller TaskController
// 2. In the migration's up(), add columns: $table->string('title');
//                                          $table->boolean('done')->default(false);
//    then run:  php artisan migrate
// 3. In the model, set protected $fillable = ['title', 'done'];
// 4. In routes/web.php add:
//      Route::get('/tasks',  [TaskController::class, 'index']);
//      Route::post('/tasks', [TaskController::class, 'store']);
// 5. In TaskController@index, fetch Task::all() and return a Blade view
//    that @foreach-es over the tasks.
// 6. In TaskController@store, $request->validate(['title' => 'required'])
//    then Task::create(...) and redirect('/tasks').
//
// ✅ Expected: visiting /tasks lists tasks; posting a title adds one.

// your code here
?>

🎉 Lesson Complete!

• ✅ composer create-project scaffolds a full app; php artisan serve runs it
• ✅ Laravel follows MVC: routes → controllers → models, with Blade views for output
• ✅ Declare routes with Route::get and point them at controller methods or closures
• ✅ Controllers fetch data and $request->validate() input before acting on it
• ✅ Eloquent maps tables to model objects; migrations define the schema, relationships link records
• ✅ Artisan generates code and runs migrations; facades and the service container wire it together

Practice quiz

Continue this course

• Previous: Final Project
• Next: GraphQL APIs in PHP — Build a typed, single-endpoint GraphQL API with schemas, queries and mutations
• Quick reference: PHP cheat sheet

Frequently asked questions

Why is Laravel the most popular PHP framework?

Laravel combines a clean, expressive syntax with batteries-included tooling: routing, the Eloquent ORM, Blade templates, the Artisan CLI, queues, authentication scaffolding, and a powerful service container all ship together. It has excellent documentation, a huge ecosystem of first-party packages (Breeze, Sanctum, Horizon, Reverb), and a large community. That mix of developer happiness and productivity is why most new PHP projects start with Laravel.

What is the difference between a migration and a model?

A migration is a versioned PHP file that describes a change to your database schema (creating a table, adding a column). You run migrations with php artisan migrate, and they let your whole team build the same database from code. A model is an Eloquent class that maps to an existing table and lets you read and write rows as objects. In short: migrations define the structure, models work with the data inside it.

What does the Artisan CLI do?

Artisan is Laravel's command-line assistant, run as php artisan <command>. It scaffolds code (make:model, make:controller, make:migration), runs and rolls back migrations (migrate, migrate:rollback), clears caches, starts a dev server (serve), runs queued jobs, and exposes a Tinker REPL for poking at your app. You can also write your own custom commands. It removes a huge amount of boilerplate.

What is the service container and why are facades useful?

The service container is Laravel's tool for dependency injection: it knows how to build your classes and their dependencies, and hands you fully-wired objects. Facades (like Cache, DB, Route) provide a short, static-looking syntax over services resolved from that container, so you write Cache::get('key') instead of manually constructing the cache manager. Despite looking static, facades are backed by real instances and can be swapped or mocked in tests.

Should I use closures or controllers for my routes?

Closures defined directly in routes/web.php are fine for tiny, one-off endpoints and quick prototypes. For anything with real logic, point the route at a controller method instead: [PostController::class, 'show']. Controllers keep related actions together, are easier to test, and let Laravel cache your routes for performance. As a rule of thumb, graduate a route from a closure to a controller as soon as it does more than return a simple view.

Related lessons

• Composer
• MVC pattern