Laravel Interview Master

Laravel is a free, open-source PHP web framework created by Taylor Otwell. It follows the model–view–controller (MVC) architectural pattern and is designed for ...

Core features include a modular packaging system with dependency management, different ways for accessing relational databases (Eloquent ORM), utilities that ai...

Artisan is the name of the command-line interface included with Laravel. It provides a number of helpful commands for your use while developing your application...

Composer is a tool for dependency management in PHP. It allows you to declare the libraries your project depends on and it will manage (install/update) them for...

Routing maps HTTP requests to specific controller actions or closures. Basic Laravel routes accept a URI and a closure, providing a very simple and expressive m...

Route::get('/hello', function () {
    return 'Hello World';
});

CSRF stands for Cross-Site Request Forgery. Laravel automatically generates a CSRF "token" for each active user session managed by the application. This token i...

Controllers can group related request handling logic into a single class. For example, a `UserController` might handle all incoming requests related to users, i...

Models in Laravel typically reside in the `app/Models` directory. The Eloquent ORM included with Laravel provides a beautiful, simple ActiveRecord implementatio...

Migrations are like version control for your database, allowing your team to define and share the application's database schema definition. They are paired with...

Views separate your application logic from your presentation logic. In Laravel, views are typically defined using the Blade templating engine and are stored in ...

Blade is the simple, yet powerful templating engine provided with Laravel. Unlike some PHP templating engines, Blade does not restrict you from using plain PHP ...

You can create a controller using the `make:controller` Artisan command.

php artisan make:controller UserController

You use the `make:model` command. You can also generate a migration simultaneously by appending `-m`.

php artisan make:model Post -m

Important directories include `app/` (core code, controllers, models), `config/` (configuration files), `database/` (migrations, seeders), `public/` (index.php,...

Laravel includes a simple method of seeding your database with test data using seed classes. All seed classes are stored in the `database/seeders` directory.

Middleware provide a convenient mechanism for inspecting and filtering HTTP requests entering your application. For example, Laravel includes a middleware that ...

Route parameters allow you to capture segments of the URI within your route. They are always encased within `{}` braces.

Route::get('/user/{id}', function ($id) { return 'User '.$id; });

`dd()` stands for 'Dump and Die'. It dumps the given variables and ends the execution of the script. It is heavily used for debugging.

Database configuration is handled primarily in the `.env` file at the root of the project, mapping to the `config/database.php` configuration file.

Eloquent is Laravel's Object-Relational Mapper (ORM). It provides an active record implementation for working with your database. Each database table has a corr...

You can create an Artisan command using `php artisan make:command NameCommand`. The logic goes into the `handle` method of the generated class.

The `public` directory contains the `index.php` file, which is the entry point for all requests entering your application. It also houses your assets such as im...

You can pass an array of data as the second argument to the `view` helper function, or use the `with` method.

return view('greetings', ['name' => 'Victoria']);

Service providers are the central place of all Laravel application bootstrapping. Your application, as well as all of Laravel's core services, are bootstrapped ...

Laravel provides several different approaches to validate your application's incoming data, such as the `validate` method available on all incoming HTTP request...

$request->validate(['title' => 'required|unique:posts|max:255']);

Dependency Injection is a design pattern used to pass dependencies into a class rather than having the class create them. Laravel's Service Container natively h...

The Laravel service container is a powerful tool for managing class dependencies and performing dependency injection. Binding and resolving are its core feature...

Facades provide a "static" interface to classes that are available in the application's service container. They serve as "proxies" to underlying classes in the ...

Eloquent relations are defined as methods on your Eloquent model classes. Types of relationships include: One To One, One To Many, Many To Many, Has One Through...

When accessing Eloquent relationships as properties, the relationship data is "lazy loaded". Eager loading (`with`) alleviates the N+1 query problem by fetching...

Accessors and mutators allow you to format Eloquent attribute values when you retrieve or set them on model instances. (e.g., getting a user's first and last na...

Form requests are custom request classes that encapsulate their own validation and authorization logic. You create them using `php artisan make:request`.

Mass assignment is when HTTP request parameters are used to blindly update or create a Model. Laravel protects against this using the `$fillable` or `$guarded` ...

All multi-result sets returned by Eloquent are instances of the `Illuminate\Database\Eloquent\Collection` object. Collections provide dozens of methods for eleg...

When injecting a model ID to a route or controller action, Route Model Binding automatically injects the model instance containing that ID directly into your ro...

Route::get('/users/{user}', function (User $user) { return $user->name; });

Laravel's events provide a simple observer implementation, allowing you to subscribe and listen for various events that occur in your application. Listeners res...

Queues allow you to defer the processing of a time-consuming task, such as sending an email, until a later time. This drastically speeds up web requests to your...

Laravel provides a unified API for various caching systems like Memcached and Redis. Caching allows you to store frequently accessed data for fast retrieval.

When building an API, you may need a transformation layer between your Eloquent models and the JSON responses returned to your users. API resources allow you to...

When models are soft deleted, they are not actually removed from your database. Instead, a `deleted_at` attribute is set on the model.

Since HTTP driven applications are stateless, sessions provide a way to store information about the user across multiple requests. Laravel supports various sess...

Entry point -> `public/index.php` -> Http Kernel -> Service Providers bootstrapped -> Router -> Middleware -> Controller -> View -> Response.

The Query Builder provides a fluent interface to creating and running simple and advanced database queries. Eloquent is an ORM built heavily on top of the Query...

Policies are classes that organize authorization logic around a particular model or resource. For example, a `PostPolicy` might authorize who can create, update...

`put` simply sets a value in the cache. `remember` will retrieve an item from cache, but if it doesn't exist, it will execute the provided closure, store its ou...

Telescope is an elegant debug assistant for the Laravel framework. It provides insight into requests, exceptions, log entries, database queries, queued jobs, ma...

You may use the `transaction` method on the `DB` facade to run a set of operations within a database transaction. If an exception is thrown within the transacti...

A polymorphic relationship allows the target model to belong to more than one type of model using a single association. For example, a `Comment` model might bel...

If you are listening for many events on a given model, you may use observers to group all of your listeners into a single class. Observers have method names tha...

Route groups allow you to share route attributes, such as middleware, controllers, or prefixes, across a large number of routes without needing to define those ...

Using PHP's reflection mechanism (Reflection API), Laravel inspects the type hints of the constructed class. It recursively resolves dependencies required by th...

`bind` resolves a new instance every time. `singleton` resolves the same instance on subsequent calls after the first resolution. `instance` binds an already ex...

If your provider is strictly registering bindings in the container, you can defer its registration until one of the bindings is requested, improving the applica...

The `Macroable` trait allows expanding classes at runtime by injecting new methods via closures. Many Laravel components (Response, Request, Collection) use it,...

Laravel Middleware sits on top of the `Illuminate\Pipeline\Pipeline` class. It passes the request through an array of closures/classes. Each has the opportunity...

Global scopes allow you to add constraints to all queries for a given model. Laravel's own `SoftDeletes` feature utilizes a global scope to only pull non-delete...

Octane boots your application once using high-performance application servers like Swoole or RoadRunner, keeping it in memory. Subsequent incoming requests are ...

Laravel has built-in casts (`array`, `json`, `date`). Custom Casts allow you to define a class that handles the serialization/deserialization logic for custom v...

Broadcasting allows you to share events between your server-side code and your client-side JavaScript applications over WebSockets using drivers like Pusher or ...

Instead of executing an event listener synchronously during the request, you can implement the `ShouldQueue` interface on the listener. Laravel will automatical...

Multi-tenancy can be handled via single database (filtering scopes per tenant ID) or multi-database schemas (dynamic database connections resolved via middlewar...

Laravel provides 'Pessimistic Locking' via `sharedLock()` and `lockForUpdate()` query builder methods. 'Optimistic Locking' is generally implemented manually vi...

Horizon provides a beautiful dashboard and code-driven configuration for Laravel-powered Redis queues. It allows you to monitor key metrics such as job throughp...

Use `morphTo` and `morphMany`. For deeply nested polymorphic queries, ensure you eager load using `with(['morphable' => function() {...}])` to avoid N+1 queries...

CSRF is only required for cookie-based stateful sessions. Stateless APIs using tokens (Bearer headers or Sanctum SPAs) don't naturally suffer from CSRF, though ...

UUIDs/ULIDs prevent ID enumeration attacks (guessing URLs), allow offline ID generation (helpful for mobile apps/distributed systems), and are required in horiz...

Reverb is a first-party, scaleable WebSocket server for Laravel 11. It's built for speed using PHP's async capabilities and integrates perfectly with Laravel's ...

`chunk()` retrieves a limited chunk of records, runs a closure over them, then retrieves the next chunk. This drastically reduces memory usage when processing t...

If you update a field that the query is filtering/ordering by, `chunk()` will skip records due to offset shifting. `chunkById()` pages using the primary key (`w...

A single cron entry calls `php artisan schedule:run` every minute. Laravel then evaluates all scheduled tasks in the `routes/console.php` (or Kernel) file, exec...

`tap` accepts a value and a closure. It executes the closure with the value, then returns the value. It's useful for chained method calls without needing to ass...

When casting Models to arrays or JSON, Laravel checks for hidden or appended attributes. Accessors are converted, mutators applied. It implements `JsonSerializa...

Eloquent is an Active Record implementation (Model contains data AND DB logic). The Repository pattern abstracts data access to interchangeable classes. While R...

Passport provides a full OAuth2 server implementation. Sanctum provides a featherweight authentication system for SPAs, mobile apps, and simple API token issuan...

Using Domain-Driven Design (DDD) principles. Moving away from standard MVC arrays to modules or bounded contexts (e.g., separating `app/Domain`, `app/Infrastruc...

Route parameter definition.

Route::get('/users/{id}', function ($id) {
    return 'User ID: ' . $id;
});

Use `has()` relationship method.

User::has('posts', '>', 5)->get();

Call update on the query builder directly.

User::where('status', 'inactive')->update(['status' => 'archived']);

In Laravel 9+ using the new syntax.

protected function firstName(): Attribute {
    return Attribute::make(
        set: fn (string $value) => strtolower($value),
    );
}

Combining first and last name.

protected function fullName(): Attribute {
    return Attribute::make(
        get: fn () => $this->first_name . ' ' . $this->last_name,
    );
}

A Post has many Comments.

class Post extends Model {
    public function comments() {
        return $this->hasMany(Comment::class);
    }
}

Using rules method.

public function rules() {
    return [
        'email' => 'required|email|unique:users,email'
    ];
}

Type hint the Model in the controller.

public function show(User $user) {
    return view('user.show', compact('user'));
}

Using DB facade.

DB::transaction(function () {
    User::create([...]);
    Profile::create([...]);
});

Use the withTrashed method.

User::withTrashed()->where('id', 1)->first();

Using Cache::remember.

$users = Cache::remember('users', 3600, function () {
    return User::all();
});

Using the onQueue method.

ProcessPodcast::dispatch($podcast)->onQueue('processing');

Using the Log facade.

Log::warning('Something could be going wrong', ['user' => $user->id]);

Common in controller form submissions.

return back()->withInput()->withErrors(['error' => 'Invalid data.']);

Use dot notation.

Book::with('author.contacts')->get();

Using the route helper.

$url = route('profile', ['id' => 1]);

Using Auth attempt.

if (Auth::attempt(['email' => $email, 'password' => $password])) {
    return redirect()->intended('dashboard');
}

Update deeply nested JSON properties.

User::where('id', 1)->update(['meta->theme' => 'dark']);

Define and apply.

protected static function booted() {
    static::addGlobalScope('active', function (Builder $builder) {
        $builder->where('active', 1);
    });
}

Using Mail facade.

Mail::to($request->user())->send(new OrderShipped($order));

Using the contains method.

if ($collection->contains('Desk')) { ... }

In the toArray method.

public function toArray($request) {
    return [
        'id' => $this->id,
        'name' => $this->name,
        // token omitted
    ];
}

Using the store method on the uploaded file.

$path = $request->file('avatar')->store('avatars', 'public');

Using Carbon or whereDate.

User::where('created_at', '>=', now()->subDays(7))->get();

Using Artisan::call.

Artisan::call('email:send', ['user' => 1, '--queue' => 'default']);