Laravel is one of the most widely used PHP frameworks for building modern web applications. Its clean syntax, expressive programming style, powerful ORM, routing system, queues, authentication tools, and developer-friendly ecosystem make it a popular choice among PHP developers.

If you are preparing for a Laravel interview, it is important to understand not only the definitions but also how Laravel features are used in real-world applications.

Here are some commonly asked Laravel interview questions and answers, covering both fundamental and intermediate concepts.

1. What is Laravel? What are the specialties of Laravel?

Laravel is an open-source PHP framework designed for developing modern web applications. It was created by Taylor Otwell and follows the Model-View-Controller (MVC) architectural pattern.

Laravel focuses on making common web-development tasks simpler through expressive syntax and built-in features.

Some of its important features include:

• Elegant and expressive syntax – Laravel provides a clean and readable coding style.
• Artisan CLI – Artisan provides numerous commands for creating files, running migrations, managing queues, clearing caches, and performing other development tasks.
• Eloquent ORM – Eloquent provides an object-oriented way to interact with databases.
• Routing – Laravel provides a powerful and flexible routing system.
• Blade templating engine – Blade allows developers to create dynamic and reusable views.
• Authentication and authorization tools – Laravel provides the foundation for authentication and authorization, with starter kits available for common authentication scaffolding.
• Queues and jobs – Time-consuming tasks can be processed in the background.
• Task scheduling – Laravel provides a convenient way to schedule recurring tasks.
• Testing support – Laravel provides tools and integrations for application testing.
• Large ecosystem and community – Laravel has a large developer community and an extensive ecosystem of packages and official tools.

2. What is Eloquent ORM?

Eloquent is Laravel's built-in Object-Relational Mapper (ORM). It allows developers to work with database records using PHP models instead of writing SQL queries for every operation.

Typically, an Eloquent model represents a database table. For example, a User model can be used to retrieve, create, update, and delete records from the users table.

For example:

$users = User::where('status', 'active')->get();

Eloquent also provides features such as model relationships, query scopes, eager loading, mass assignment protection, attribute casting, and more.

This makes database-related code easier to read and maintain.

3. What is Eager Loading in Laravel?

Eager loading is used when you want to load a model's related records along with the main records.

It is particularly useful for avoiding unnecessary database queries and reducing the N+1 query problem.

For example:

$posts = Post::with('comments')->get();

Here, Laravel retrieves the posts and their related comments efficiently instead of querying the comments separately for every post.

Eager loading is especially useful when working with relationships such as hasMany, belongsTo, and belongsToMany.

4. What is Lazy Loading in Laravel?

Lazy loading means that a related model is loaded only when the relationship is actually accessed.

For example:

$post = Post::find(1);

$comments = $post->comments;

When the Post model is retrieved, its comments are not necessarily loaded immediately. When $post->comments is accessed, Laravel loads the related comments.

Lazy loading is convenient, but it should be used carefully in loops because it can result in the N+1 query problem. In such situations, eager loading is generally more appropriate.

5. What is Dependency Injection?

Dependency Injection is a design technique in which a class receives the objects or services it depends on from an external source rather than creating those dependencies itself.

In Laravel, dependencies can commonly be injected through constructors. Laravel's service container can automatically resolve many class dependencies.

For example:

class UserManager
{
    public function __construct(
        protected Logger $log
    ) {
    }

    public function registerUser($name)
    {
        // User registration logic

        $this->log->log($name);
    }
}

Here, UserManager depends on the Logger class. Instead of creating a Logger object manually inside UserManager, Laravel can inject it into the constructor.

Dependency injection makes code easier to test, maintain, and extend.

6. What is the Service Container in Laravel?

Laravel's Service Container is a system used to manage class dependencies and perform dependency injection.

It can resolve classes automatically and can also be used to bind interfaces to their implementations.

For example, if an application uses an interface such as PaymentGateway, the service container can be configured to resolve it to a particular implementation.

The service container is an important part of Laravel's dependency management system and is used behind the scenes when Laravel resolves controllers, middleware, jobs, event listeners, and other classes.

7. What is a Service Provider?

A Service Provider is a central place for registering and bootstrapping services used by a Laravel application.

Service providers are commonly used to register service container bindings and perform application-specific setup.

A service provider generally contains two important methods:

• register() – Used for registering bindings and services with the service container.
• boot() – Used for performing actions after the application's services have been registered.

For example, a custom service can be registered inside a service provider and then injected wherever it is required.

Service providers play an important role in Laravel's application bootstrapping process.

8. What is a Collection in Laravel?

A Laravel Collection is an object-oriented wrapper around arrays that provides a large number of useful methods for working with sets of data.

Collections make it easier to filter, transform, sort, group, and manipulate data without writing lengthy loops.

For example:

$numbers = collect([1, 2, 3, 4, 5]);

$evenNumbers = $numbers->filter(function ($number) {
    return $number % 2 === 0;
});

Laravel collections include methods such as map(), filter(), sort(), groupBy(), pluck(), reduce(), and many others.

Collections are commonly used when working with Eloquent query results.

9. What is the Repository Pattern?

The Repository Pattern is a software design pattern used to separate data-access logic from the rest of the application's business logic.

A repository provides an abstraction layer between the application and the data source.

For example, instead of putting all database queries directly inside a controller, you could place user-related data-access operations inside a UserRepository.

This can make a large application easier to organize and test.

However, the Repository Pattern is not mandatory in Laravel. Eloquent already provides a powerful database abstraction layer, so introducing repositories should be based on the application's requirements rather than simply following a rule.

10. What is Middleware in Laravel? Give an example.

Middleware provides a convenient mechanism for inspecting and filtering HTTP requests entering an application.

A middleware can perform an action before or after a request reaches the application's controller or route.

For example, authentication middleware can check whether a user is logged in before allowing access to a protected page.

Other common uses of middleware include:

• Authentication
• Request logging
• Rate limiting
• Checking user permissions
• Adding or modifying request information
• Handling maintenance mode

For example:

Route::get('/dashboard', function () {
    return view('dashboard');
})->middleware('auth');

In this example, the authentication middleware ensures that the route is accessible only to authenticated users.

11. How can you check whether Composer is installed?

Composer is the dependency manager used by PHP projects, including Laravel applications.

To check whether Composer is installed, you can run:

composer --version

You can also simply run:

composer

If Composer is installed correctly, the command will display Composer's available commands and information.

12. How can you check the Laravel version?

You can check the Laravel version of an application using Artisan:

php artisan --version

For example, the command may display something similar to:

Laravel Framework 13.x.x

You can also inspect the laravel/framework dependency in the application's composer.json file.

13. Which command is used to list available Artisan commands?

Laravel provides a command-line interface called Artisan.

To see the available Artisan commands, run:

php artisan list

This displays the commands available in the current Laravel application.

You can also get information about a specific command using:

php artisan help migrate

Artisan is commonly used for tasks such as creating controllers, generating models, running migrations, managing queues, clearing caches, and more.

14. What are Packages in Laravel?

In older Laravel terminology, you may come across the term Bundles, but modern Laravel applications generally use the term Packages.

A Laravel package is a reusable piece of software that adds functionality to a Laravel application.

Depending on the package, it may contain features such as:

• Configuration files
• Routes
• Controllers
• Views
• Database migrations
• Commands
• Service providers
• Translations

Packages allow developers to reuse functionality instead of implementing everything from scratch.

Laravel has a large ecosystem of community and official packages.

15. What is Routing in Laravel?

Routing is the process of defining how an application responds to different HTTP requests and URLs.

For example:

Route::get('/users', [UserController::class, 'index']);

This route tells Laravel to call the index method of UserController when a GET request is made to /users.

Laravel routing supports several HTTP methods, including:

• GET
• POST
• PUT
• PATCH
• DELETE
• OPTIONS

Laravel also provides features such as named routes, route groups, route model binding, middleware, route parameters, and resource routes.

16. What is the difference between Factories and Seeders?

Both factories and seeders can be used to populate a Laravel application's database, but they serve different purposes.

Factories

Factories define how fake model data should be generated. They are commonly used when creating test or development data.

For example:

User::factory()->count(10)->create();

This can create multiple users using the model factory definition.

Seeders

Seeders are classes used to insert data into the database.

They are often used for inserting initial, default, or development data.

For example, a seeder might create an administrator account or populate a list of predefined categories.

Factories and seeders are also commonly used together:

User::factory()->count(50)->create();

inside a seeder can generate a large amount of sample data.

17. Which command is used to list all registered routes?

Laravel provides the following Artisan command:

php artisan route:list

It displays the application's registered routes along with useful information such as:

• HTTP method
• URI
• Route name
• Controller or action
• Middleware

This command is particularly useful when debugging routing-related issues.

18. What is the difference between Authentication and Authorization?

Authentication and authorization are two different security concepts.

Authentication

Authentication determines who the user is.

For example, when a user logs in using an email address and password, the application verifies the user's identity.

Authorization

Authorization determines what an authenticated user is allowed to do.

For example, a user may be authenticated but may not have permission to delete another user's account.

In simple terms:

Authentication = Who are you?

Authorization = What are you allowed to do?

Laravel provides authentication and authorization features to help developers implement these security requirements.

19. What is a CSRF Token in Laravel?

CSRF stands for Cross-Site Request Forgery.

A CSRF attack attempts to trick an authenticated user's browser into sending an unwanted request to an application.

Laravel provides CSRF protection for web requests that modify application state.

When creating an HTML form for methods such as POST, PUT, PATCH, or DELETE, you can use the Blade @csrf directive:

<form method="POST" action="/profile">
    @csrf

    <!-- Form fields -->
</form>

Laravel generates a CSRF token associated with the user's session, and the request can then be validated by the application's request-forgery protection.

It is important to note that you do not simply need to add @csrf to every HTML form regardless of its method. It is particularly relevant for state-changing requests protected by Laravel's web middleware.

20. What is a Facade in Laravel?

A Facade provides a simple, expressive interface for accessing services available through Laravel's service container.

For example:

use Illuminate\Support\Facades\Cache;

$value = Cache::get('key');

Here, Cache is a Laravel Facade that provides a convenient interface for interacting with Laravel's caching services.

Laravel provides many facades, including:

• Cache
• DB
• Log
• Mail
• Storage
• Route
• Auth

Facades make Laravel code concise and readable while still providing access to services managed by the framework.

21. What is a Queue in Laravel?

A queue allows an application to postpone time-consuming tasks and process them in the background.

For example, suppose an application needs to send an email after a user places an order. Instead of making the user wait while the email is processed, the application can place the email task onto a queue.

Common examples of queued tasks include:

• Sending emails
• Processing uploaded images
• Generating reports
• Sending notifications
• Processing large amounts of data
• Calling external services

A queue worker then processes these jobs in the background.

This can improve the responsiveness of the application because the user does not have to wait for every time-consuming operation to finish.

22. What is Event Broadcasting in Laravel?

Event broadcasting allows Laravel events occurring on the server to be delivered to client-side applications in real time.

It is commonly used for features such as:

• Real-time notifications
• Chat applications
• Live dashboards
• Real-time status updates
• Collaborative applications

For example, when a new message is created, Laravel can broadcast an event that allows connected clients to receive the message without repeatedly refreshing the page.

Laravel supports several broadcasting drivers, including Laravel Reverb, Pusher Channels, Ably, Mercure, and others. Broadcasting is not enabled automatically in a new Laravel application and can be installed when required.

23. What is Composer?

Composer is the dependency manager for PHP.

Laravel uses Composer to install the Laravel framework and manage third-party PHP packages used by an application.

For example:

composer require guzzlehttp/guzzle

This command adds the Guzzle package to the application.

Composer also handles dependency versions and generates the autoloader used by PHP applications.

The Laravel application itself is managed through Composer dependencies, so understanding basic Composer commands is important for Laravel developers.

24. What are Named Routes in Laravel?

Named routes are routes that are assigned a unique name.

For example:

Route::get('/profile', [ProfileController::class, 'index'])
    ->name('profile');

Once the route has a name, you can reference it using the route name instead of hard-coding the URL:

$url = route('profile');

Named routes are useful because if the URL changes later, the code that references the route name does not necessarily need to change.

They are commonly used for generating URLs and redirects.

25. What is Reverse Routing in Laravel?

Reverse routing refers to generating a URL from a route definition or, more commonly, from a named route.

For example:

Route::get('/profile', [ProfileController::class, 'index'])
    ->name('profile');

You can generate the corresponding URL using:

$url = route('profile');

Instead of manually writing /profile throughout the application, you can use the route name.

This makes applications easier to maintain when URLs change.

26. How can you create a new Laravel project?

There are several ways to create a Laravel application.

The Laravel installer is the recommended approach in the current Laravel installation documentation:

composer global require laravel/installer

After installing the Laravel installer, you can create a new application using:

laravel new testProject

Another commonly used approach is Composer's create-project command:

composer create-project laravel/laravel testProject

The important distinction is that composer create-project creates the application and installs its Composer dependencies; it does not mean that the Laravel installer itself is installed globally every time.

The Laravel installer approach is convenient when you regularly create new Laravel applications.

27. What is a Migration in Laravel?

A migration is a version-controlled way of managing changes to a database schema.

Instead of manually creating or modifying database tables, developers can define those changes in migration files.

For example, a migration can be used to:

• Create a new table
• Add a column
• Modify a column
• Add an index
• Remove a column
• Drop a table

A migration can be executed using:

php artisan migrate

Migrations make it easier for development teams to keep their database structure synchronized across different environments.

Laravel stores migration files in the database/migrations directory.

28. What are Accessors and Mutators in Laravel?

Accessors and mutators allow developers to customize how Eloquent model attributes are retrieved and assigned.

Accessor

An accessor allows you to transform an attribute when it is accessed.

For example, you may want to format a user's name before displaying it.

Mutator

A mutator allows you to transform or prepare an attribute when it is assigned to the model.

For example, you might normalize a value before storing it in the database.

Modern Laravel uses the Attribute class for defining accessors and mutators.

Example:

use Illuminate\Database\Eloquent\Casts\Attribute;

protected function fullName(): Attribute
{
    return Attribute::make(
        get: fn ($value, $attributes) =>
            $attributes['first_name'] . ' ' . $attributes['last_name'],
    );
}

Accessors and mutators are useful when you want to keep attribute-related transformation logic inside the model rather than repeating it throughout controllers and views.

29. What is the Difference Between CSRF and XSS Attacks?

CSRF and XSS are both web security vulnerabilities, but they work in different ways.

CSRF

Cross-Site Request Forgery attempts to make a user's browser send an unwanted request to a website where the user is already authenticated.

For example, an attacker may attempt to trick an authenticated user into submitting a request that changes an account setting.

CSRF protection helps verify that a state-changing request is legitimate.

XSS

Cross-Site Scripting occurs when an attacker manages to inject malicious JavaScript or other executable content into a web page that is viewed by other users.

Depending on the vulnerability and the application's security controls, an XSS attack can potentially be used to perform actions in the victim's browser, manipulate page content, or access information available to scripts.

In simple terms:

CSRF: Tricks a user's browser into making an unwanted request.

XSS: Injects malicious script into content that is executed in a user's browser.

They are different vulnerabilities and require different security measures.

30. What are Policies and Gates in Laravel?

Policies and Gates are Laravel's authorization mechanisms. They help determine whether a user is allowed to perform a particular action.

Policies

Policies are classes that organize authorization logic around a particular model or resource.

For example, you could create a PostPolicy to determine whether a user can:

• View a post
• Create a post
• Update a post
• Delete a post

A policy keeps authorization rules organized instead of placing them throughout controllers.

Gates

Gates provide a more lightweight, closure-based way to define authorization rules.

For example:

Gate::define('update-post', function (User $user, Post $post) {
    return $user->id === $post->user_id;
});

You can then check whether the current user is authorized to perform the action.

A simple way to remember the difference is:

Gates: Useful for defining individual authorization rules.

Policies: Useful for organizing authorization rules around a model or resource.

Both approaches are part of Laravel's authorization system.