What are migrations in Laravel?

 Migrations are version-controlled definitions of database schema changes.

Example:
Schema::create('products', function (Blueprint $table) {
$table->id();
$table->string('name');
$table->decimal('price', 10, 2);
$table->timestamps();
});

Commands:
php artisan make:migration create_products_table
php artisan migrate

Migrations allow a development team to reproduce schema changes consistently across environments.

Scenario:
When a team adds a sku column, the migration becomes part of source control and can be applied to development, staging, and production according to the deployment process.

Read More

What is mass assignment in Eloquent?

 Mass assignment allows multiple model attributes to be assigned from an array, for example:

Product::create([
'name' => $data['name'],
'price' => $data['price'],
]);

Laravel provides protection mechanisms so developers explicitly define which attributes may be mass assigned or otherwise control assignment behavior.

A common risk is accepting arbitrary request data:
Model::create($request->all());

Scenario:
If a users table contains an administrative flag, blindly accepting request data could allow a malicious client to submit fields that should never be user-controlled.

Interview tip:
Explain why validated data and explicit model assignment are important security boundaries.

Read More

What is a Form Request in Laravel?

 A Form Request is a dedicated request class that can contain validation and authorization logic.

Example:
class StoreProductRequest extends FormRequest
{
public function authorize(): bool
{
return true;
}

public function rules(): array
{
return [
'name' => ['required', 'string', 'max:255'],
'price' => ['required', 'numeric', 'min:0'],
];
}
}

Controller:
public function store(StoreProductRequest $request)
{
$data = $request->validated();
}

Scenario:
As a project grows, moving validation out of controllers keeps controllers smaller and makes validation rules reusable and testable.

Read More

What is Laravel validation and why should it be used?

 Validation checks incoming data against application rules before business logic uses it.

Example:
$request->validate([
'name' => ['required', 'string', 'max:255'],
'email' => ['required', 'email'],
]);

For larger forms, a Form Request is often cleaner.

Validation protects data integrity and provides a predictable boundary between untrusted input and application logic.

Scenario:
An order endpoint should validate product IDs, quantities, shipping information, and payment-related fields before attempting to create an order.

Read More

What are Blade layouts and components?

 Layouts provide a reusable page structure, while components encapsulate reusable UI pieces.

A layout may contain:
header
navigation
main content
footer

A component might represent:
button
alert
modal
product card
form field

Example component usage:
<x-product-card :product="$product" />

Scenario:
A SaaS dashboard may have one dashboard layout and dozens of reusable UI components. This reduces duplicated markup and makes UI changes safer.

Read More

Why is {{ }} generally preferred over {!! !!} in Blade?

 Blade's {{ }} syntax escapes output, helping protect against HTML injection and XSS when displaying untrusted content.

Example:
{{ $comment->body }}

Raw output:
{!! $html !!}

Raw output should only be used when the HTML is trusted or has been safely sanitized.

Scenario:
If a comment contains <script>...</script>, escaped rendering prevents the browser from treating the content as executable HTML.

Interview tip:
Never claim that Blade escaping makes an application automatically secure. Security depends on the complete data flow, validation, sanitization requirements, database usage, authentication, authorization, and frontend behavior.

Read More

What is Blade in Laravel?

 Blade is Laravel's templating engine. It provides a clean syntax for rendering dynamic HTML while allowing normal PHP when necessary.

Example:
<h1>{{ $product->name }}</h1>

Conditional:
@if($product->in_stock)
<span>Available</span>
@else
<span>Out of stock</span>
@endif

Blade also supports layouts, components, slots, loops, includes, and escaped output.

Scenario:
A product page can use a shared application layout and reusable product-card components rather than duplicating HTML across many views.

Read More

What is a resource controller in Laravel?

 A resource controller provides conventional actions for CRUD-style resources.

Typical actions are:
index
create
store
show
edit
update
destroy

Example:
Route::resource('products', ProductController::class);

This can generate conventional routes such as:
GET /products
POST /products
GET /products/{product}
PUT/PATCH /products/{product}
DELETE /products/{product}

Scenario:
An admin product-management module maps naturally to resource routing.

Interview follow-up:
Explain when you would not use resource routing—for example, when an endpoint represents an operation rather than a conventional CRUD resource.

Read More

What is a controller in Laravel and what should it contain?

 A controller coordinates an HTTP request and application response. It should generally remain focused on request-level orchestration rather than becoming a giant business-logic class.

Example:
public function store(StoreProductRequest $request)
{
$product = $this->productService->create(
$request->validated()
);

return redirect()->route('products.show', $product);
}

Scenario:
If a controller contains validation, payment processing, inventory calculations, email delivery, reporting, and ten database queries, maintenance becomes difficult. Those responsibilities can be separated into requests, services, domain classes, jobs, and models where appropriate.

There is no universal requirement that every controller must call a service. Simple CRUD operations can remain simple. The goal is cohesive, maintainable code.

Read More

What is the difference between authentication and authorization in Laravel?

 Authentication answers: "Who are you?"

Authorization answers: "Are you allowed to perform this action?"

Authentication may establish the current user through a session, token, or another mechanism.

Authorization can use gates or policies.

Example:
if ($user->can('update', $post)) {
// allow update
}

Scenario:
A support employee may be authenticated but still be forbidden from deleting financial records. Authentication identifies the employee; authorization determines whether deletion is permitted.

Interview tip:
Do not describe authentication and authorization as the same thing. This distinction is fundamental to secure application design.

Read More

What is middleware in Laravel?

 Middleware is a layer that inspects or modifies an HTTP request before it reaches the application endpoint and can also process the outgoing response.

Conceptual flow:
Request -> Middleware -> Controller -> Response -> Middleware -> Client

Example:
public function handle($request, Closure $next)
{
if (!$request->user()) {
return redirect('/login');
}

return $next($request);
}

Common uses include authentication, authorization, rate limiting, logging, CORS, maintenance mode, and request normalization.

Scenario:
An /admin area can be protected with authentication and authorization middleware so that unauthenticated or unauthorized requests never reach the controller.

Read More

What is Laravel route model binding?

 Route model binding lets Laravel resolve a route parameter into an Eloquent model.

Example:
Route::get('/products/{product}', [ProductController::class, 'show']);

Controller:
public function show(Product $product)
{
return $product;
}

Instead of manually doing Product::findOrFail($id), Laravel can resolve the model.

Scenario:
For /products/25, Laravel can retrieve Product 25 and automatically produce a not-found response when appropriate.

A developer should understand custom keys as well, such as binding by slug rather than numeric ID. This is useful for SEO-friendly URLs.

Interview follow-up:
Explain the difference between implicit and explicit binding and how scoped bindings work for nested resources.

Read More

What are route parameters in Laravel?

 Route parameters allow dynamic values to be captured from a URL.

Example:
Route::get('/products/{id}', function ($id) {
return $id;
});

For /products/25, id is 25.

Parameters can be constrained:
Route::get('/products/{id}', ...)->whereNumber('id');

Optional parameters can be written using ? when appropriate:
Route::get('/user/{name?}', ...);

Scenario:
An admin application may use /orders/{order} to identify an order. Route parameters are useful for resource-oriented URLs and become more powerful when combined with implicit model binding.

Read More

What are named routes in Laravel and why are they useful?

 Interview Answer:

A named route gives a route a stable application-level name. Instead of hard-coding URLs throughout the application, code can refer to the route by name.

Example:
Route::get('/products', [ProductController::class, 'index'])
->name('products.index');

Then:
return redirect()->route('products.index');

Blade:
<a href="{{ route('products.index') }}">Products</a>

Scenario:
If /products changes to /catalog/products, code using route('products.index') does not need to change. Only the route definition changes.

Named routes are particularly useful for redirects, links, forms, authorization logic, testing, and URL generation.

Read More

What is the difference between routes/web.php and routes/api.php?

 Interview Answer:

Laravel separates web-oriented and API-oriented routes so that applications can apply different middleware, state-management, and response conventions. Web routes normally support browser sessions, cookies, CSRF protection, and Blade responses. API routes are intended for stateless HTTP APIs and commonly return JSON.

Example:
Route::get('/products', [ProductController::class, 'index']);

For a browser page, the route may return a Blade view. For an API, the same business operation can return a JSON resource.

Scenario:
An e-commerce application has a customer website and a mobile application. Website routes can use session authentication and CSRF protection, while mobile/API routes can use token authentication. Keeping these concerns separated makes the application easier to reason about.

Interview follow-up:
Ask what middleware group each route uses in the Laravel version being discussed. Laravel's exact route bootstrap configuration can differ between major versions, so a strong answer should avoid assuming an old project structure.

Read More

What is a Service Provider?

 Difficulty: Intermediate → Advanced

Service providers are central places for bootstrapping application services.

They can register bindings and perform initialization.

Conceptually:

Application starts
       ↓
Service providers load
       ↓
Services registered
       ↓
Application bootstrapped

A service provider can register an interface implementation:

$this->app->bind(
    PaymentGateway::class,
    StripePaymentGateway::class
);

Then application code can depend on:

PaymentGateway

rather than directly depending on:

StripePaymentGateway

This helps maintain loose coupling.

---

The important interview progression

For this 1000-question bank, we'll deliberately progress from:

PHP
 ↓
Laravel Fundamentals
 ↓
Routing
 ↓
Controllers
 ↓
Blade
 ↓
Validation
 ↓
MySQL
 ↓
Migrations
 ↓
Eloquent
 ↓
Relationships
 ↓
APIs
 ↓
Authentication
 ↓
OAuth
 ↓
Social Login
 ↓
AJAX/jQuery
 ↓
Services
 ↓
Repositories
 ↓
Events
 ↓
Queues
 ↓
Redis
 ↓
Testing
 ↓
Security
 ↓
Performance
 ↓
Deployment
 ↓
Architecture
 ↓
Real Production Projects

Read More

What is Laravel's service container?

 Difficulty: Advanced

The service container is responsible for managing dependencies and resolving classes.

For example:

class OrderService
{
    public function __construct(
        private PaymentGateway $gateway
    ) {}
}

Laravel can determine how to construct OrderService when its dependencies have been registered appropriately.

Bindings can be configured in service providers.

Conceptually:

Interface
    ↓
Container Binding
    ↓
Concrete Implementation
    ↓
Dependency Injection

This becomes extremely valuable in large applications.

Read More

What is dependency injection in Laravel?

 Difficulty: Intermediate → Advanced

Dependency injection means providing a class with the objects it needs instead of having the class construct those objects itself.

Consider:

class OrderController
{
    public function __construct(
        private OrderService $orderService
    ) {}
}

Laravel's service container can resolve the dependency.

The controller doesn't need:

$this->orderService = new OrderService();

This provides several benefits:

Loose coupling
Testability
Maintainability
Replaceable implementations
Cleaner architecture

For example, you could depend on an interface:

interface PaymentGateway
{
    public function charge(int $amount): bool;
}

and inject an implementation.

This becomes especially useful when an application supports:

Stripe
PayPal
Razorpay
Internal payment gateway
Mock payment gateway for testing

Read More

What is the difference between Eloquent ORM and Query Builder?

 Difficulty: Intermediate

Both can interact with the database, but their abstraction levels differ.

Eloquent

Works primarily through models:

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

Query Builder

Works more directly with database queries:

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

Eloquent is particularly useful when your application uses:

Models
Relationships
Scopes
Casts
Model events
Accessors
Mutators
Business behavior

Query Builder can be useful for:

Complex SQL-style queries
Aggregations
Specialized joins
Performance-sensitive query construction
Queries that don't map naturally to a model

The appropriate choice depends on the problem rather than treating one as universally superior.

Read More

What is Eloquent ORM?

 Difficulty: Beginner → Intermediate

Interview Level: Junior → Senior

Eloquent is Laravel's ORM — Object-Relational Mapper.

It allows developers to work with database records using PHP models rather than writing every database operation manually in SQL.

For example:

$product = Product::find(10);

Instead of manually writing:

SELECT *
FROM products
WHERE id = 10;

Eloquent represents the database table through a model:

class Product extends Model
{
}

Then:

$product->name

can access a database attribute.

---

Creating records

$product = Product::create([
    'name' => 'Laptop',
    'price' => 75000,
]);

---

Updating

$product->update([
    'price' => 70000,
]);

---

Deleting

$product->delete();

---

Relationships

Suppose:

User
 ↓
Orders

The User model might contain:

public function orders()
{
    return $this->hasMany(Order::class);
}

Then:

$user->orders;

can retrieve the user's related orders.

This is one of Eloquent's most powerful features.

Read More

What is Composer and why does Laravel use it?

 Difficulty: Beginner → Intermediate

Composer is PHP's dependency manager.

Laravel itself depends on many PHP packages.

A Laravel project therefore has:

composer.json
composer.lock
vendor/

For example:

{
    "require": {
        "laravel/framework": "..."
    }
}

Composer installs the required dependencies into:

vendor/

The application loads these dependencies through Composer's autoloader.

A common command is:

composer install

For development:

composer update

should be used carefully because it can update dependency versions according to the project's constraints.

Read More