Laravel Interview Cheat Sheet

Comprehensive Laravel framework reference for technical interviews covering MVC architecture, Eloquent ORM, authentication, performance optimization, and modern Laravel 11 features. Master these concepts to excel in full-stack PHP positions requiring Laravel expertise.

Key Areas: Core Architecture • Eloquent & Database • Authentication • Queues & Jobs • Caching • API Development • Testing • Laravel 11+ Features

Service Container (IoC Container)

// Binding - Register services
app()->bind('PaymentGateway', function() {
    return new StripeGateway(config('stripe.key'));
});

// Singleton - Single instance
app()->singleton('Cart', function() {
    return new ShoppingCart();
});

// Resolving - Get service instance
$gateway = app('PaymentGateway');
$gateway = app()->make(PaymentGateway::class);

// Dependency Injection via constructor
class OrderController {
    public function __construct(
        private PaymentGateway $gateway  // Auto-resolved
    ) {}
}

Request Lifecycle

1. public/index.php → Entry point
2. Bootstrap → Load composer, create app instance
3. HTTP Kernel → Handle request
4. Service Providers → Register & boot
5. Router → Match route
6. Middleware Stack → Process request
7. Controller → Execute action
8. Response → Return to client

Service Providers

class AppServiceProvider extends ServiceProvider {
    public function register(): void {
        // Register bindings (called first)
        $this->app->bind(Interface::class, Implementation::class);
    }
    
    public function boot(): void {
        // Bootstrap services (called after all register)
        View::share('appName', config('app.name'));
    }
}

Essential Directories

app/Http/Controllers/   # Request handlers
app/Models/            # Eloquent models  
app/Services/          # Business logic
database/migrations/   # Schema versions
resources/views/       # Blade templates
routes/               # web.php, api.php

Common Commands

# Create controller
php artisan make:controller UserController

# Create model with migration
php artisan make:model User -m

# Run migrations
php artisan migrate

# Rollback migrations
php artisan migrate:rollback

# Create middleware
php artisan make:middleware AuthMiddleware

# Clear cache
php artisan cache:clear

# Create seeder
php artisan make:seeder UserSeeder

# Run seeders
php artisan db:seed

Basic Routes

// routes/web.php
Route::get('/users', function () {
    return 'Users';
});

Route::post('/users', [UserController::class, 'store']);
Route::put('/users/{id}', [UserController::class, 'update']);
Route::delete('/users/{id}', [UserController::class, 'destroy']);

Route Parameters

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

// Optional parameter
Route::get('/user/{name?}', function ($name = 'Guest') {
    return "Hello $name";
});

// Regular expression constraint
Route::get('/user/{id}', function ($id) {
    //
})->where('id', '[0-9]+');

Route Groups

Route::prefix('admin')->group(function () {
    Route::get('/users', [AdminController::class, 'users']);
    Route::get('/posts', [AdminController::class, 'posts']);
});

Route::middleware(['auth'])->group(function () {
    Route::get('/dashboard', [DashboardController::class, 'index']);
});

Named Routes

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

// Using named route
return redirect()->route('profile');

Basic Controller

namespace App\Http\Controllers;

class UserController extends Controller
{
    public function index()
    {
        $users = User::all();
        return view('users.index', compact('users'));
    }
    
    public function show($id)
    {
        $user = User::findOrFail($id);
        return view('users.show', compact('user'));
    }
    
    public function store(Request $request)
    {
        $user = User::create($request->validated());
        return redirect()->route('users.show', $user);
    }
}

Resource Controller

// Create resource controller
php artisan make:controller UserController --resource

// Register resource routes
Route::resource('users', UserController::class);
// Creates: index, create, store, show, edit, update, destroy

API Controller

class UserController extends Controller
{
    public function index()
    {
        return response()->json(User::all());
    }
    
    public function store(Request $request)
    {
        $user = User::create($request->validated());
        return response()->json($user, 201);
    }
}

Model Definition

namespace App\Models;

use Illuminate\Database\Eloquent\Model;

class User extends Model
{
    protected $fillable = ['name', 'email', 'password'];
    
    protected $hidden = ['password', 'remember_token'];
    
    protected $casts = [
        'email_verified_at' => 'datetime',
        'is_admin' => 'boolean',
    ];
}

Basic Operations

// Create - O(1) single insert
$user = User::create(['name' => 'John', 'email' => 'john@example.com']);

// Read - O(1) with primary key, O(n) with WHERE
$user = User::find(1);  // Uses primary key index
$users = User::where('active', true)->get();  // Full table scan without index
$user = User::where('email', 'john@example.com')->first();  // Stops at first match

// Update - O(n) based on WHERE condition
$user->update(['name' => 'Jane']);  // Single row
User::where('active', false)->update(['status' => 'inactive']);  // Bulk update

// Delete - O(1) for single, O(n) for multiple
$user->delete();  // Soft delete if enabled
User::destroy([1, 2, 3]);  // Multiple deletes

Query Scopes

class User extends Model
{
    // Local scope
    public function scopeActive($query)
    {
        return $query->where('active', true);
    }
    
    // Global scope
    protected static function booted()
    {
        static::addGlobalScope('active', function ($query) {
            $query->where('active', true);
        });
    }
}

// Usage
$activeUsers = User::active()->get();

Accessors & Mutators (Laravel 9+ Attribute Casting)

use Illuminate\Database\Eloquent\Casts\Attribute;

class User extends Model
{
    // Modern accessor/mutator (Laravel 9+)
    protected function fullName(): Attribute
    {
        return Attribute::make(
            get: fn () => "{$this->first_name} {$this->last_name}",
            set: fn ($value) => [
                'first_name' => explode(' ', $value)[0],
                'last_name' => explode(' ', $value)[1] ?? '',
            ]
        );
    }
    
    // Password with hashing
    protected function password(): Attribute
    {
        return Attribute::make(
            set: fn ($value) => bcrypt($value)
        );
    }
}

// Usage
echo $user->full_name;        // John Doe
$user->full_name = 'Jane Smith';  // Sets first_name & last_name
$user->password = 'secret';   // Automatically hashed

One-to-One

class User extends Model
{
    public function profile()
    {
        return $this->hasOne(Profile::class);
    }
}

class Profile extends Model
{
    public function user()
    {
        return $this->belongsTo(User::class);
    }
}

One-to-Many

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

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

Many-to-Many

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

class Role extends Model
{
    public function users()
    {
        return $this->belongsToMany(User::class);
    }
}

// With pivot table data
return $this->belongsToMany(Role::class)->withPivot('expires_at');

Polymorphic Relations

class Comment extends Model
{
    public function commentable()
    {
        return $this->morphTo();
    }
}

class Post extends Model
{
    public function comments()
    {
        return $this->morphMany(Comment::class, 'commentable');
    }
}

Eager Loading

// Prevent N+1 problem - O(2) queries instead of O(n+1)
$users = User::with('posts')->get();  // 2 queries total
$users = User::with(['posts', 'profile'])->get();  // 3 queries
$users = User::with('posts.comments')->get();  // Nested relations

// Lazy eager loading - Load after retrieval
$users = User::all();
$users->load('posts');  // Triggers additional query

// Conditional eager loading
$users = User::with(['posts' => function ($query) {
    $query->where('published', true);
}])->get();

Create Migration

Schema::create('users', function (Blueprint $table) {
    $table->id();
    $table->string('name');
    $table->string('email')->unique();
    $table->timestamp('email_verified_at')->nullable();
    $table->string('password');
    $table->rememberToken();
    $table->timestamps();
    
    $table->index('email');
    $table->foreign('role_id')->references('id')->on('roles');
});

Modify Table

Schema::table('users', function (Blueprint $table) {
    $table->string('phone')->after('email');
    $table->dropColumn('address');
    $table->renameColumn('name', 'full_name');
});

Common Column Types

$table->bigIncrements('id');
$table->string('title', 100);
$table->text('description');
$table->integer('votes');
$table->decimal('amount', 8, 2);
$table->boolean('confirmed');
$table->enum('status', ['pending', 'approved']);
$table->json('options');
$table->date('birth_date');
$table->dateTime('published_at');
$table->softDeletes();

Controller Validation

public function store(Request $request)
{
    $validated = $request->validate([
        'name' => 'required|string|max:255',
        'email' => 'required|email|unique:users',
        'password' => 'required|min:8|confirmed',
        'age' => 'nullable|integer|between:18,100',
    ]);
    
    User::create($validated);
}

Form Request Validation

class StoreUserRequest extends FormRequest
{
    public function authorize()
    {
        return true;
    }
    
    public function rules()
    {
        return [
            'name' => 'required|string|max:255',
            'email' => 'required|email|unique:users',
        ];
    }
    
    public function messages()
    {
        return [
            'name.required' => 'Name is required',
            'email.unique' => 'Email already exists',
        ];
    }
}

Common Validation Rules (Compact Reference)

'required'                    // Not empty
'nullable'                    // Can be null
'string|max:255'             // String, max length
'integer|min:0|max:100'      // Integer range
'email:rfc,dns'              // Valid email with DNS check
'unique:users,email'         // Unique in table
'exists:roles,id'            // Must exist in table
'confirmed'                  // field_confirmation match
'date|after:tomorrow'        // Date validation
'regex:/^[A-Z]+$/'          // Pattern match
'in:admin,user'             // Enum values
'array|min:1'               // Array with min items
'file|mimes:pdf|max:2048'   // File validation (2MB)

Create & Register Middleware

namespace App\Http\Middleware;

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

// Register in app/Http/Kernel.php
protected $routeMiddleware = [
    'age' => \App\Http\Middleware\CheckAge::class,
];

// Use in routes
Route::get('/adult', function () {
    //
})->middleware('age');

Common Built-in Middleware

Route::middleware(['auth'])->group(function () {});
Route::middleware(['guest'])->group(function () {});
Route::middleware(['throttle:60,1'])->group(function () {});
Route::middleware(['verified'])->group(function () {});

Basic Auth Setup

// Install Laravel Breeze/Jetstream/Fortify
composer require laravel/breeze --dev
php artisan breeze:install
npm install && npm run dev
php artisan migrate

Manual Authentication

use Illuminate\Support\Facades\Auth;

// Attempt login
if (Auth::attempt(['email' => $email, 'password' => $password])) {
    $request->session()->regenerate();
    return redirect()->intended('dashboard');
}

// Check if authenticated
if (Auth::check()) {
    // User is logged in
}

// Get authenticated user
$user = Auth::user();
$id = Auth::id();

// Logout
Auth::logout();

Guards

// config/auth.php
'guards' => [
    'web' => ['driver' => 'session', 'provider' => 'users'],
    'api' => ['driver' => 'token', 'provider' => 'users'],
    'admin' => ['driver' => 'session', 'provider' => 'admins'],
]

// Using guards
Auth::guard('admin')->attempt($credentials);
Auth::guard('api')->user();

Basic Syntax

{{-- Comments --}}
{{ $variable }} {{-- Escaped output --}}
{!! $html !!} {{-- Unescaped output --}}

@if ($user)
    <p>{{ $user->name }}</p>
@elseif ($guest)
    <p>Guest</p>
@else
    <p>No user</p>
@endif

@foreach ($users as $user)
    <li>{{ $user->name }}</li>
@endforeach

@for ($i = 0; $i < 10; $i++)
    <p>{{ $i }}</p>
@endfor

@while (true)
    <p>Infinite loop</p>
@endwhile

Layouts & Sections

{{-- layouts/app.blade.php --}}
<html>
<head>
    <title>@yield('title', 'Default Title')</title>
</head>
<body>
    @yield('content')
</body>
</html>

{{-- pages/home.blade.php --}}
@extends('layouts.app')

@section('title', 'Home Page')

@section('content')
    <h1>Welcome</h1>
@endsection

Components

{{-- components/alert.blade.php --}}
<div class="alert alert-{{ $type }}">
    {{ $slot }}
</div>

{{-- Usage --}}
<x-alert type="success">
    Operation successful!
</x-alert>

Directives

@auth
    // User is authenticated
@endauth

@guest
    // User is guest
@endguest

@can('update', $post)
    // User can update post
@endcan

@csrf {{-- CSRF token field --}}
@method('PUT') {{-- Method spoofing --}}

@include('partials.header')
@includeWhen($user, 'partials.user')

@empty($records)
    No records found
@endempty

Basic Operations

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

// Filter
$filtered = $collection->filter(function ($value) {
    return $value > 2;
});

// Map
$multiplied = $collection->map(function ($item) {
    return $item * 2;
});

// Reduce
$sum = $collection->reduce(function ($carry, $item) {
    return $carry + $item;
}, 0);

// Contains
$collection->contains(3); // true
$collection->contains('key', 'value');

// Pluck
$names = $users->pluck('name');
$names = $users->pluck('name', 'id'); // Keyed by ID

Advanced Methods

// Chunk
$chunks = $collection->chunk(3);

// Group By
$grouped = $collection->groupBy('category');

// Sort
$sorted = $collection->sort();
$sorted = $collection->sortBy('price');

// Unique
$unique = $collection->unique();

// Where
$filtered = $collection->where('price', '>', 100);

// First/Last
$first = $collection->first();
$last = $collection->last();

// Take/Skip
$items = $collection->take(3);
$items = $collection->skip(2);

// Flatten
$flat = $collection->flatten();

// Merge
$merged = $collection->merge(['extra']);

Basic Queries

use Illuminate\Support\Facades\DB;

// Select
$users = DB::table('users')->get();
$user = DB::table('users')->where('name', 'John')->first();
$email = DB::table('users')->where('name', 'John')->value('email');
$names = DB::table('users')->pluck('name');

// Insert
DB::table('users')->insert([
    'name' => 'John',
    'email' => 'john@example.com'
]);

// Update
DB::table('users')
    ->where('id', 1)
    ->update(['votes' => 1]);

// Delete
DB::table('users')->where('votes', '<', 100)->delete();

Advanced Queries

// Joins
$users = DB::table('users')
    ->join('posts', 'users.id', '=', 'posts.user_id')
    ->select('users.*', 'posts.title')
    ->get();

// Aggregates
$count = DB::table('users')->count();
$max = DB::table('orders')->max('price');
$avg = DB::table('orders')->avg('price');

// Group By & Having
$users = DB::table('users')
    ->groupBy('account_id')
    ->having('account_id', '>', 100)
    ->get();

// Order By
$users = DB::table('users')
    ->orderBy('name', 'desc')
    ->get();

// Raw Expressions
$users = DB::table('users')
    ->select(DB::raw('count(*) as user_count'))
    ->whereRaw('age > ?', [25])
    ->get();

Define Event

namespace App\Events;

class OrderShipped
{
    public $order;
    
    public function __construct($order)
    {
        $this->order = $order;
    }
}

Define Listener

namespace App\Listeners;

class SendShipmentNotification
{
    public function handle(OrderShipped $event)
    {
        // Send email to $event->order->user
    }
}

Register & Dispatch

// EventServiceProvider
protected $listen = [
    OrderShipped::class => [
        SendShipmentNotification::class,
    ],
];

// Dispatch event
event(new OrderShipped($order));
// or
OrderShipped::dispatch($order);

Create Job

namespace App\Jobs;

class ProcessPayment implements ShouldQueue
{
    use Dispatchable, InteractsWithQueue, Queueable, SerializesModels;
    
    public $order;
    
    public function __construct($order)
    {
        $this->order = $order;
    }
    
    public function handle()
    {
        // Process payment
    }
}

Dispatch Jobs

// Dispatch now
ProcessPayment::dispatch($order);

// Dispatch with delay
ProcessPayment::dispatch($order)->delay(now()->addMinutes(10));

// Dispatch to specific queue
ProcessPayment::dispatch($order)->onQueue('payments');

// Dispatch conditionally
ProcessPayment::dispatchIf($condition, $order);

Queue Configuration

# .env
QUEUE_CONNECTION=database

# Run queue worker
php artisan queue:work
php artisan queue:work --queue=high,default

Basic Cache Operations

use Illuminate\Support\Facades\Cache;

// Store - O(1) for Redis/Memcached
Cache::put('key', 'value', 3600);  // TTL: 1 hour
Cache::forever('key', 'value');    // No expiration

// Retrieve - O(1) lookup
$value = Cache::get('key');
$value = Cache::get('key', 'default');

// Check existence - O(1)
if (Cache::has('key')) {
    // Cached
}

// Delete - O(1) for single key
Cache::forget('key');
Cache::flush();  // O(n) - Clears entire cache!

// Remember pattern - Cache miss: O(query), Cache hit: O(1)
$users = Cache::remember('users', 3600, function () {
    return User::with('posts')->get();  // Expensive query cached
});

Cache Tags

Cache::tags(['people', 'artists'])->put('John', $john, 3600);
Cache::tags(['people', 'authors'])->put('Jane', $jane, 3600);

// Flush tagged cache
Cache::tags(['people'])->flush();

Basic Operations

use Illuminate\Support\Facades\Storage;

// Store file
Storage::put('file.txt', $contents);
Storage::putFile('photos', $request->file('photo'));

// Retrieve
$contents = Storage::get('file.txt');
$exists = Storage::exists('file.txt');

// Download
return Storage::download('file.txt');

// Delete
Storage::delete('file.txt');
Storage::delete(['file1.txt', 'file2.txt']);

// URLs
$url = Storage::url('file.txt');
$temporaryUrl = Storage::temporaryUrl('file.txt', now()->addMinutes(5));

Unit Testing

namespace Tests\Unit;

use Tests\TestCase;

class UserTest extends TestCase
{
    public function test_user_has_full_name()
    {
        $user = new User(['first_name' => 'John', 'last_name' => 'Doe']);
        $this->assertEquals('John Doe', $user->full_name);
    }
}

Feature Testing

namespace Tests\Feature;

class UserTest extends TestCase
{
    public function test_users_can_register()
    {
        $response = $this->post('/register', [
            'name' => 'John Doe',
            'email' => 'john@example.com',
            'password' => 'password',
            'password_confirmation' => 'password',
        ]);
        
        $response->assertRedirect('/home');
        $this->assertDatabaseHas('users', [
            'email' => 'john@example.com',
        ]);
    }
}

Database Testing

use Illuminate\Foundation\Testing\RefreshDatabase;

class ExampleTest extends TestCase
{
    use RefreshDatabase; // Migrates fresh database
    
    public function test_database()
    {
        // Use factories
        $user = User::factory()->create();
        
        // Assertions
        $this->assertDatabaseHas('users', [
            'email' => $user->email,
        ]);
        
        $this->assertDatabaseMissing('users', [
            'email' => 'notfound@example.com',
        ]);
    }
}

API Routes

// routes/api.php
Route::middleware('auth:sanctum')->group(function () {
    Route::apiResource('posts', PostController::class);
});

API Resources

namespace App\Http\Resources;

class UserResource extends JsonResource
{
    public function toArray($request)
    {
        return [
            'id' => $this->id,
            'name' => $this->name,
            'email' => $this->email,
            'posts' => PostResource::collection($this->whenLoaded('posts')),
            'created_at' => $this->created_at->toDateTimeString(),
        ];
    }
}

// Usage
return new UserResource($user);
return UserResource::collection($users);

API Authentication (Sanctum)

// Install
composer require laravel/sanctum

// User model
use Laravel\Sanctum\HasApiTokens;

class User extends Authenticatable
{
    use HasApiTokens;
}

// Issue token
$token = $user->createToken('token-name')->plainTextToken;

// Revoke tokens
$user->tokens()->delete();

CSRF Protection

{{-- In forms --}}
<form method="POST">
    @csrf
    {{-- Form fields --}}
</form>

SQL Injection Prevention

// Bad - vulnerable
DB::select("SELECT * FROM users WHERE email = '$email'");

// Good - parameterized
DB::select("SELECT * FROM users WHERE email = ?", [$email]);

// Good - query builder
DB::table('users')->where('email', $email)->get();

XSS Prevention

{{-- Escaped by default --}}
{{ $userInput }}

{{-- Only use for trusted content --}}
{!! $trustedHtml !!}

Mass Assignment Protection

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

Environment Variables

// Never commit .env file
// Access using env() only in config files
config('app.key'); // Not env('APP_KEY')

Database Optimization

// Eager loading - prevent N+1
$users = User::with('posts')->get();

// Select only needed columns
$users = User::select('id', 'name')->get();

// Chunk for large datasets
User::chunk(100, function ($users) {
    foreach ($users as $user) {
        // Process
    }
});

// Use indexes in migrations
$table->index('email');

Caching Strategies

// Cache expensive queries
$users = Cache::remember('users', 3600, function () {
    return User::with('posts')->get();
});

// Route caching
php artisan route:cache

// Config caching
php artisan config:cache

// View caching
php artisan view:cache

Query Optimization

// Use exists() instead of count()
if (User::where('email', $email)->exists()) {
    // More efficient than count() > 0
}

// Use increment/decrement
$post->increment('views');

// Bulk insert
DB::table('users')->insert($userData);

ACID Properties & Transaction Management

use Illuminate\Support\Facades\DB;

// Basic transaction - Auto-commits/rollbacks
DB::transaction(function () {
    DB::update('UPDATE users SET votes = 1');
    DB::delete('DELETE FROM posts WHERE views < 100');
});  // Atomic: all or nothing

// Manual transaction control
DB::beginTransaction();
try {
    $user = User::create($userData);
    $user->account()->create($accountData);
    
    DB::commit();  // ACID compliant
} catch (\Exception $e) {
    DB::rollBack();
    throw $e;
}

// Transaction with retry on deadlock
DB::transaction(function () use ($order) {
    $order->update(['status' => 'processing']);
    // Process payment...
}, 5);  // Retry up to 5 times

// Multiple database connections
DB::connection('mysql')->transaction(function () {
    // MySQL operations
});

Model Events & Lifecycle Hooks

// Model events - Performance: synchronous execution
class User extends Model {
    protected static function booted() {
        static::creating(function ($user) {
            $user->uuid = Str::uuid();
        });
        
        static::deleting(function ($user) {
            $user->posts()->delete();  // Cascade - O(n) queries
        });
    }
}

// Observer class - Cleaner for multiple events
class UserObserver {
    public function creating(User $user): void {
        $user->uuid = Str::uuid();
    }
    
    public function created(User $user): void {
        // Async via queue for better performance
        SendWelcomeEmail::dispatch($user);
    }
    
    public function updating(User $user): void {
        if ($user->isDirty('email')) {
            $user->email_verified_at = null;
        }
    }
    
    public function deleted(User $user): void {
        Cache::forget("user.{$user->id}");
    }
}

// Register in service provider
User::observe(UserObserver::class);

Creating Reusable Validation

use Illuminate\Contracts\Validation\ValidationRule;

// Class-based rule (Laravel 10+)
class Uppercase implements ValidationRule {
    public function validate(string $attribute, mixed $value, Closure $fail): void {
        if (strtoupper($value) !== $value) {
            $fail('The :attribute must be uppercase.');
        }
    }
}

// Inline custom rule
Validator::extend('phone', function ($attribute, $value, $parameters, $validator) {
    return preg_match('/^\+?[1-9]\d{1,14}$/', $value);  // E.164 format
});

// Using custom rules
$request->validate([
    'name' => ['required', new Uppercase],
    'phone' => 'required|phone'
]);

// Rule with parameters
class MinWords implements ValidationRule {
    public function __construct(private int $min) {}
    
    public function validate(string $attribute, mixed $value, Closure $fail): void {
        if (str_word_count($value) < $this->min) {
            $fail("The :attribute must have at least {$this->min} words.");
        }
    }
}

Real-time Events with WebSockets

// Broadcast event
class OrderShipped implements ShouldBroadcast {
    use Dispatchable, InteractsWithSockets, SerializesModels;
    
    public function __construct(
        public Order $order
    ) {}
    
    public function broadcastOn(): Channel {
        return new PrivateChannel('user.'.$this->order->user_id);
    }
    
    public function broadcastAs(): string {
        return 'order.shipped';
    }
    
    public function broadcastWith(): array {
        return ['id' => $this->order->id, 'status' => 'shipped'];
    }
}

// Frontend (Echo.js)
Echo.private(`user.${userId}`)
    .listen('.order.shipped', (e) => {
        console.log('Order shipped:', e.id);
    });

// Presence channels - Track online users
Echo.join(`chat.${roomId}`)
    .here(users => console.log('Users:', users))
    .joining(user => console.log('Joined:', user))
    .leaving(user => console.log('Left:', user));

High-Performance Laravel (10-30x faster)

// Install & start Octane
composer require laravel/octane
php artisan octane:install  // Choose Swoole/RoadRunner
php artisan octane:start --workers=4 --max-requests=500

// Concurrent tasks - Parallel execution
use Laravel\Octane\Facades\Octane;

[$users, $posts, $stats] = Octane::concurrently([
    fn () => User::count(),
    fn () => Post::count(),
    fn () => Cache::get('stats')
]);  // Executes simultaneously, not sequentially

// In-memory cache between requests
Octane::table('users', 1000)  // Max 1000 rows
    ->set('user:1', ['name' => 'John', 'email' => 'john@example.com']);

$user = Octane::table('users')->get('user:1');

// Octane-specific considerations
class Service {
    // Avoid memory leaks - reset state
    public function handle() {
        $this->data = [];  // Clear after each request
    }
}

Repository Pattern Implementation

interface UserRepositoryInterface {
    public function find(int $id): ?User;
    public function findByEmail(string $email): ?User;
    public function paginate(int $perPage = 15);
}

class EloquentUserRepository implements UserRepositoryInterface {
    public function find(int $id): ?User {
        return User::with('profile')->find($id);  // Eager load
    }
    
    public function findByEmail(string $email): ?User {
        return Cache::remember("user.email.{$email}", 3600, function () use ($email) {
            return User::where('email', $email)->first();
        });
    }
    
    public function paginate(int $perPage = 15) {
        return User::with('posts')  // Prevent N+1
            ->orderBy('created_at', 'desc')
            ->paginate($perPage);
    }
}

// Register in service provider
$this->app->bind(UserRepositoryInterface::class, EloquentUserRepository::class);

Common Laravel Packages

• laravel/telescope - Debug & monitoring
• laravel/horizon - Queue dashboard
• laravel/sanctum - API authentication
• spatie/laravel-permission - Roles & permissions
• barryvdh/laravel-debugbar - Debug toolbar
• laravel/socialite - OAuth authentication

Latest Framework Updates

// Laravel 11 - Simplified directory structure
// No more Http/Kernel.php, middleware in bootstrap/app.php
return Application::configure(basePath: dirname(__DIR__))
    ->withRouting(
        web: __DIR__.'/../routes/web.php',
        api: __DIR__.'/../routes/api.php',
    )
    ->withMiddleware(function (Middleware $middleware) {
        $middleware->web(append: [
            CustomMiddleware::class,
        ]);
    })
    ->create();

// Laravel 11 - Health check endpoint
Route::health('/up');  // Built-in health check

// Laravel 11 - Per-second rate limiting
Route::middleware('throttle:10,1')->group(function () {
    // 10 requests per second
});

// Laravel 11 - Eager load limit
User::with(['posts' => function ($query) {
    $query->limit(5);  // Properly limits per parent
}])->get();

// Laravel 10+ Process facade
use Illuminate\Support\Facades\Process;
$result = Process::run('ls -la');
$result = Process::pipe([
    'cat file.txt',
    'grep "pattern"',
    'wc -l'
]);

// Feature flags with Pennant
use Laravel\Pennant\Feature;
if (Feature::active('new-checkout-flow')) {
    // New feature code
}
Feature::for($user)->activate('beta-features');

Must-Know Concepts (High Frequency)

✅ Service Container & Dependency Injection
✅ Request Lifecycle (entry → response)
✅ Eloquent N+1 Problem & Solutions
✅ Database Transactions (ACID)
✅ Authentication vs Authorization
✅ Queue Implementation & Use Cases
✅ Caching Strategies (DB, Route, Config)
✅ API Resources & Versioning
✅ Testing (Unit vs Feature vs Integration)
✅ Security (CSRF, XSS, SQL Injection)

Common Pitfalls & Red Flags

// ❌ NEVER: Use env() outside config
$key = env('API_KEY');  // Returns null in production!

// ✅ CORRECT: Use config()
$key = config('services.api.key');

// ❌ NEVER: N+1 queries
$users = User::all();
foreach ($users as $user) {
    echo $user->posts->count();  // N queries!
}

// ✅ CORRECT: Eager load
$users = User::withCount('posts')->get();
foreach ($users as $user) {
    echo $user->posts_count;  // No extra queries
}

// ❌ NEVER: Raw user input in queries
DB::select("SELECT * FROM users WHERE email = '{$request->email}'");

// ✅ CORRECT: Parameterized queries
DB::select('SELECT * FROM users WHERE email = ?', [$request->email]);

Performance Optimization Checklist

• Database: Indexes on foreign keys, WHERE, ORDER BY columns
• Eloquent: Use select() to limit columns
• Caching: Cache expensive queries with remember()
• Queues: Offload heavy tasks to background jobs
• Eager Loading: Always use with() for relationships
• Pagination: Use paginate() instead of get() for large datasets
• Chunking: Process large datasets with chunk()
• Octane: Consider for high-traffic applications

Interview Success Tips

• Explain the "why" behind architectural decisions
• Mention performance implications of choices
• Discuss trade-offs (e.g., caching vs real-time data)
• Show awareness of security best practices
• Demonstrate understanding of SOLID principles
• Be ready to write code on whiteboard/screen share