Laravel is a PHP web application framework that provides structure, tools, and conventions so developers don't have to rebuild common functionality from scratch.

It follows the MVC (Model-View-Controller) pattern and includes tools for routing, ORM, templating (Blade), queues, caching, and testing out of the box.

Understanding this helps when debugging where a request 'stops' - e.g. a middleware rejecting it, or a service provider not being registered.

Eloquent is Laravel's ActiveRecord-style ORM. Each database table has a corresponding Model class used to interact with that table.

// Raw SQL
$users = DB::select('SELECT * FROM users WHERE active = 1');

// Eloquent
$users = User::where('active', 1)->get();

// Relationships in Eloquent
class Post extends Model {
    public function comments() {
        return $this->hasMany(Comment::class);
    }
}
$post->comments; // lazy-loaded collection

Middleware acts as a filtering layer for HTTP requests entering your application - for example checking authentication before allowing access to a route.

php artisan make:middleware CheckAge

class CheckAge
{
    public function handle($request, Closure $next)
    {
        if ($request->age < 18) {
            return redirect('home');
        }
        return $next($request);
    }
}

Register it in app/Http/Kernel.php, then apply it to routes:

Route::get('profile', function () {
    // ...
})->middleware('checkage');

Migrations are version control for your database schema, written as PHP code instead of manual SQL, so schema changes can be tracked, shared, and rolled back.

php artisan make:migration create_posts_table

public function up()
{
    Schema::create('posts', function (Blueprint $table) {
        $table->id();
        $table->string('title');
        $table->text('body');
        $table->timestamps();
    });
}

public function down()
{
    Schema::dropIfExists('posts');
}

class User extends Model {
    public function posts() {
        return $this->hasMany(Post::class);
    }
}
class Post extends Model {
    public function user() {
        return $this->belongsTo(User::class);
    }
}
class User extends Model {
    public function roles() {
        return $this->belongsToMany(Role::class);
    }
}

The service container is a tool for managing class dependencies and performing dependency injection - it automatically resolves and injects classes your code depends on.

// Binding in a service provider
$this->app->bind(PaymentGateway::class, function ($app) {
    return new StripeGateway(config('services.stripe.key'));
});

// Automatic resolution via type-hinting
class OrderController extends Controller
{
    public function __construct(protected PaymentGateway $gateway) {}
}

Because Laravel resolves PaymentGateway automatically, you can swap StripeGateway for a different implementation (e.g. in tests) without changing the controller.

Both control mass assignment protection - preventing attackers from setting unintended fields via bulk input like User::create($request->all()).

class User extends Model
{
    protected $fillable = ['name', 'email', 'password'];
    // OR
    protected $guarded = ['is_admin', 'id'];
}

Using $fillable is generally safer since new sensitive columns are protected by default rather than needing to be explicitly added to a blacklist.

Blade is Laravel's templating engine that compiles templates into plain PHP code, which is then cached for performance until the source file changes.

{{-- resources/views/welcome.blade.php --}}
@extends('layouts.app')

@section('content')
    <h1>Hello, {{ $name }}</h1>
    @if ($user->isAdmin())
        <p>Welcome, admin!</p>
    @endif
    @foreach ($posts as $post)
        <p>{{ $post->title }}</p>
    @endforeach
@endsection

Facades provide a static-looking interface to classes registered in the service container, giving expressive syntax without sacrificing testability.

// Using a facade
Cache::put('key', 'value', 600);

// What happens internally:
// 1. Cache::put() is intercepted by __callStatic()
// 2. Facade resolves the underlying 'cache' binding from the container
// 3. put() is called on that resolved instance