PHP Laravel developer sollicitatievragen testen zowel framework-kennis als software design principes. Met Laravel 13 uitgebracht in maart 2026, met de AI SDK, PHP Attributes en Passkey authenticatie, verwachten interviewers dat kandidaten zowel kennis van huidige features als kernfundamenten demonstreren.

Interview Focusgebieden

Laravel interviews behandelen doorgaans vijf pijlers: Eloquent ORM relaties en performance, Service Container en dependency injection, authenticatie- en autorisatiepatronen, queue- en job handling, en teststrategieën. Senior rollen voegen architectuurbeslissingen en kennis van het package-ecosysteem toe.

Eloquent ORM en Database Vragen

Eloquent blijft het meest besproken onderwerp in Laravel interviews. Interviewers beoordelen of kandidaten lazy vs eager loading, relatietypes en query-optimalisatie begrijpen.

V: Wat is het N+1 query probleem en hoe lost Laravel het op?

Het N+1 probleem treedt op wanneer code één query uitvoert om een collectie op te halen, en vervolgens N extra queries voor gerelateerde data van elk item. Laravel biedt eager loading via with() als oplossing.

app/Http/Controllers/PostController.phpphp

// N+1 probleem: 1 query voor posts + N queries voor auteurs
$posts = Post::all();
foreach ($posts as $post) {
    echo $post->author->name; // Triggert een query per post
}

// Oplossing: Eager load met with()
$posts = Post::with('author')->get(); // 2 queries totaal
foreach ($posts as $post) {
    echo $post->author->name; // Geen extra query
}

Laravel 13 behoudt de strict mode in development, die een exception gooit wanneer lazy loading optreedt, waardoor N+1 problemen vroeg worden ontdekt.

V: Leg het verschil uit tussen hasOne, hasMany, belongsTo en belongsToMany.

Relatie	Foreign Key Locatie	Voorbeeld
hasOne	In gerelateerd model	User hasOne Profile (profiles.user_id)
hasMany	In gerelateerd model	User hasMany Posts (posts.user_id)
belongsTo	In huidig model	Post belongsTo User (posts.user_id)
belongsToMany	Pivot tabel	User belongsToMany Roles (role_user tabel)

V: Hoe worden soft deletes afgehandeld en wat zijn de implicaties?

app/Models/Post.phpphp

use Illuminate\Database\Eloquent\SoftDeletes;

class Post extends Model
{
    use SoftDeletes;
    
    // Soft-deleted records worden standaard uitgesloten
    // Om ze in te sluiten:
    // Post::withTrashed()->get();
    // Om alleen verwijderde op te halen:
    // Post::onlyTrashed()->get();
}

Soft deletes voegen een deleted_at kolom toe. Queries sluiten soft-deleted records automatisch uit tenzij expliciet gevraagd. Dit beïnvloedt unique constraints en vereist samengestelde indexen die deleted_at bevatten voor optimale performance.

Service Container en Dependency Injection

De Service Container is het hart van Laravel. Het begrijpen van binding, resolution en contextuele injection onderscheidt ervaren developers van beginners.

V: Wat is het verschil tussen bind() en singleton() in de Service Container?

app/Providers/AppServiceProvider.phpphp

use App\Services\PaymentGateway;
use App\Services\StripeGateway;

public function register(): void
{
    // bind() maakt elke keer een nieuwe instantie
    $this->app->bind(PaymentGateway::class, function ($app) {
        return new StripeGateway(config('services.stripe.key'));
    });
    
    // singleton() maakt eenmaal en hergebruikt dezelfde instantie
    $this->app->singleton(PaymentGateway::class, function ($app) {
        return new StripeGateway(config('services.stripe.key'));
    });
}

bind() maakt een verse instantie bij elke resolution, terwijl singleton() de instantie cachet voor de gehele levensduur van het request. Singleton moet worden gebruikt voor stateless services of resources die duur zijn om te instantiëren.

V: Hoe werkt Contextual Binding?

app/Providers/AppServiceProvider.phpphp

use App\Http\Controllers\PhotoController;
use App\Http\Controllers\VideoController;
use App\Services\LocalStorage;
use App\Services\S3Storage;
use App\Contracts\StorageInterface;

public function register(): void
{
    $this->app->when(PhotoController::class)
              ->needs(StorageInterface::class)
              ->give(LocalStorage::class);
              
    $this->app->when(VideoController::class)
              ->needs(StorageInterface::class)
              ->give(S3Storage::class);
}

Contextual binding maakt verschillende implementaties mogelijk op basis van de consumerende klasse, zonder meerdere interfaces of Service Locator patterns te vereisen.

Authenticatie en Autorisatie

Laravel 13 introduceert native Passkey ondersteuning terwijl het bestaande authenticatiesysteem behouden blijft. Interviewvragen testen vaak het begrip van beide benaderingen.

V: Vergelijk Gates en Policies voor autorisatie.

app/Providers/AppServiceProvider.phpphp

use App\Models\Post;
use App\Models\User;
use Illuminate\Support\Facades\Gate;

public function boot(): void
{
    // Gate: Eenvoudige closure-gebaseerde check
    Gate::define('update-post', function (User $user, Post $post) {
        return $user->id === $post->user_id;
    });
}

// app/Policies/PostPolicy.php
class PostPolicy
{
    // Policy: Klassemethoden voor complexe autorisatie
    public function update(User $user, Post $post): bool
    {
        return $user->id === $post->user_id;
    }
    
    public function delete(User $user, Post $post): bool
    {
        return $user->id === $post->user_id 
            || $user->hasRole('admin');
    }
}

Gates zijn geschikt voor eenvoudige, eenmalige checks. Policies organiseren autorisatielogica per Model en integreren automatisch met controller methoden via Model binding.

V: Hoe implementeer je Rate Limiting voor APIs?

app/Providers/AppServiceProvider.phpphp

use Illuminate\Cache\RateLimiting\Limit;
use Illuminate\Support\Facades\RateLimiter;

public function boot(): void
{
    RateLimiter::for('api', function ($request) {
        return Limit::perMinute(60)->by(
            $request->user()?->id ?: $request->ip()
        );
    });
    
    // Gedifferentieerde limiting voor premium gebruikers
    RateLimiter::for('uploads', function ($request) {
        return $request->user()?->isPremium()
            ? Limit::perMinute(100)
            : Limit::perMinute(10);
    });
}

Klaar om je Laravel gesprekken te halen?

Oefen met onze interactieve simulatoren, flashcards en technische tests.

Ontdek Laravel

Queues en Jobs

Achtergrondverwerking met queues is cruciaal voor schaalbare Laravel applicaties. Interviewers beoordelen het begrip van job design, foutafhandeling en monitoring.

V: Wat is het verschil tussen dispatch() en dispatchSync()?

app/Http/Controllers/OrderController.phpphp

use App\Jobs\ProcessOrder;

public function store(Request $request)
{
    $order = Order::create($request->validated());
    
    // Asynchroon: Job wordt in queue geplaatst
    ProcessOrder::dispatch($order);
    
    // Synchroon: Job wordt direct uitgevoerd in hetzelfde request
    ProcessOrder::dispatchSync($order);
    
    // Na response: Wordt uitgevoerd na verzending van HTTP response
    ProcessOrder::dispatchAfterResponse($order);
}

dispatch() plaatst jobs in de queue voor latere verwerking door workers. dispatchSync() voert direct uit en is nuttig voor testen of wanneer resultaten direct nodig zijn. dispatchAfterResponse() vertraagt uitvoering tot na voltooiing van de HTTP response.

V: Hoe worden gefaalde jobs afgehandeld?

app/Jobs/ProcessPayment.phpphp

class ProcessPayment implements ShouldQueue
{
    use Dispatchable, InteractsWithQueue, Queueable, SerializesModels;
    
    public int $tries = 3;
    public int $backoff = 60; // Seconden tussen pogingen
    public int $timeout = 120;
    
    public function handle(): void
    {
        // Verwerkingslogica
    }
    
    public function failed(\Throwable $exception): void
    {
        // Stuur notificatie, log fout etc.
        Log::error('Betalingsverwerking mislukt', [
            'order_id' => $this->order->id,
            'error' => $exception->getMessage(),
        ]);
    }
    
    public function retryUntil(): DateTime
    {
        return now()->addHours(24);
    }
}

Laravel biedt automatische retries, exponentiële backoff en een tabel voor gefaalde jobs. De failed() methode maakt aangepaste foutafhandeling mogelijk zoals notificaties of compenserende transacties.

Teststrategieën

Laravel tests omvatten unit tests, feature tests en browser tests. Interviewers verwachten begrip van alle drie niveaus.

V: Hoe worden database-afhankelijkheden in tests afgehandeld?

tests/Feature/PostControllerTest.phpphp

use App\Models\Post;
use App\Models\User;
use Illuminate\Foundation\Testing\RefreshDatabase;

class PostControllerTest extends TestCase
{
    use RefreshDatabase;
    
    public function test_user_can_create_post(): void
    {
        $user = User::factory()->create();
        
        $response = $this->actingAs($user)->post('/posts', [
            'title' => 'Mijn eerste bericht',
            'content' => 'Berichtinhoud hier',
        ]);
        
        $response->assertRedirect('/posts');
        $this->assertDatabaseHas('posts', [
            'title' => 'Mijn eerste bericht',
            'user_id' => $user->id,
        ]);
    }
}

RefreshDatabase reset de database tussen tests met transacties voor snelheid. Voor grote test suites migreert LazilyRefreshDatabase alleen wanneer nodig.

V: Hoe worden externe APIs gemockt in tests?

tests/Feature/PaymentTest.phpphp

use App\Services\StripeService;
use Mockery;

public function test_payment_processing(): void
{
    $mock = Mockery::mock(StripeService::class);
    $mock->shouldReceive('charge')
         ->once()
         ->with(1000, 'tok_visa')
         ->andReturn(['id' => 'ch_123', 'status' => 'succeeded']);
    
    $this->app->instance(StripeService::class, $mock);
    
    $response = $this->post('/checkout', [
        'amount' => 1000,
        'token' => 'tok_visa',
    ]);
    
    $response->assertJson(['status' => 'succeeded']);
}

Architectuur en Best Practices

Senior posities vereisen architecturaal beslissingsvermogen en begrip van Laravel ecosysteem conventies.

V: Wanneer moeten Events en Listeners worden gebruikt versus directe service calls?

Events ontkoppelen acties van hun neveneffecten. Een UserRegistered event kan meerdere listeners triggeren: email versturen, analytics loggen, Slack notificeren. Elke listener kan in de queue worden geplaatst en onafhankelijk falen.

app/Events/UserRegistered.phpphp

class UserRegistered
{
    public function __construct(public User $user) {}
}

// app/Listeners/SendWelcomeEmail.php
class SendWelcomeEmail implements ShouldQueue
{
    public function handle(UserRegistered $event): void
    {
        Mail::to($event->user)->send(new WelcomeMail());
    }
}

Directe service calls zijn gepast wanneer de actie een returnwaarde vereist of wanneer er slechts één consumer is.

V: Leg het Repository Pattern uit in Laravel applicaties.

Het Repository Pattern abstraheert data access logica van business logica. Hoewel Eloquent al abstractie biedt, voegen repositories een extra laag toe voor testbare, verwisselbare implementaties.

app/Repositories/PostRepository.phpphp

interface PostRepositoryInterface
{
    public function findBySlug(string $slug): ?Post;
    public function getPublished(): Collection;
}

class EloquentPostRepository implements PostRepositoryInterface
{
    public function findBySlug(string $slug): ?Post
    {
        return Post::where('slug', $slug)->first();
    }
    
    public function getPublished(): Collection
    {
        return Post::where('published', true)
                   ->orderBy('created_at', 'desc')
                   ->get();
    }
}

De Laravel community debatteert over dit pattern. Sommigen beweren dat Eloquent Models al repositories zijn. Anderen geven de voorkeur aan de extra testbaarheid en de mogelijkheid om implementaties te wisselen.

Laravel 13 Nieuwe Features

Interviewers verwachten kennis van recente framework wijzigingen en hun praktische toepassingen.

V: Wat is de nieuwe AI SDK in Laravel 13?

Laravel 13 introduceert een first-party AI SDK die meerdere LLM providers abstraheert achter een uniforme API.

config/ai.php configureert providersphp

use Illuminate\Support\Facades\AI;

$response = AI::chat()
    ->system('Je bent een behulpzame assistent.')
    ->user('Leg dependency injection uit.')
    ->generate();

// Streaming ondersteuning
AI::chat()
    ->user('Schrijf een gedicht over Laravel.')
    ->stream(function (string $chunk) {
        echo $chunk;
    });

De SDK ondersteunt OpenAI, Anthropic en lokale modellen via Ollama. Het beheert automatisch API keys, retries en response parsing.

V: Hoe werken PHP Attributes voor routing in Laravel 13?

app/Http/Controllers/UserController.phpphp

use Illuminate\Routing\Attributes\Get;
use Illuminate\Routing\Attributes\Post;
use Illuminate\Routing\Attributes\Middleware;

#[Middleware('auth')]
class UserController extends Controller
{
    #[Get('/users', name: 'users.index')]
    public function index(): View
    {
        return view('users.index');
    }
    
    #[Post('/users', name: 'users.store')]
    public function store(StoreUserRequest $request): RedirectResponse
    {
        // Gebruiker aanmaken
    }
}

Attribute-gebaseerde routing bestaat naast traditionele route bestanden. Het brengt route definities dichter bij controller methoden en maakt de code zelfdocumenterend.

Conclusie

Voorbereiding op Laravel interviews vereist zowel theoretisch begrip als praktische ervaring. De behandelde vragen vormen een solide basis, maar interviewers zullen dieper graven in gebieden specifiek voor hun projecten. Regelmatig oefenen met Laravel projecten, het lezen van framework broncode en het volgen van officiële release notes verstevigt de kennis. De beste manier om een Laravel interview te doorstaan is het bouwen van echte applicaties en het diepgaand begrijpen van de patronen die het framework implementeert.