PHP Laravel Entwickler Interviewfragen prüfen sowohl Framework-Kenntnisse als auch Software-Design-Prinzipien. Mit Laravel 13, das im März 2026 veröffentlicht wurde und das AI SDK, PHP Attributes sowie Passkey-Authentifizierung einführt, erwarten Interviewer von Kandidaten sowohl Kenntnis aktueller Features als auch der Kerngrundlagen.

Interview-Schwerpunkte

Laravel-Interviews decken typischerweise fünf Säulen ab: Eloquent ORM Beziehungen und Performance, Service Container und Dependency Injection, Authentifizierungs- und Autorisierungsmuster, Queue- und Job-Handling sowie Teststrategien. Senior-Positionen erfordern zusätzlich Architekturentscheidungen und Kenntnisse des Paket-Ökosystems.

Eloquent ORM und Datenbankfragen

Eloquent bleibt das meistdiskutierte Thema in Laravel-Interviews. Interviewer bewerten, ob Kandidaten Lazy vs. Eager Loading, Beziehungstypen und Query-Optimierung verstehen.

F: Was ist das N+1 Query Problem und wie löst Laravel es?

Das N+1 Problem tritt auf, wenn Code eine Query ausführt, um eine Collection zu laden, und dann N zusätzliche Queries für die zugehörigen Daten jedes Elements. Laravel bietet Eager Loading via with() als Lösung.

app/Http/Controllers/PostController.phpphp

// N+1 Problem: 1 Query für Posts + N Queries für Autoren
$posts = Post::all();
foreach ($posts as $post) {
    echo $post->author->name; // Triggert eine Query pro Post
}

// Lösung: Eager Load mit with()
$posts = Post::with('author')->get(); // 2 Queries insgesamt
foreach ($posts as $post) {
    echo $post->author->name; // Keine zusätzliche Query
}

Laravel 13 behält den Strict Mode in der Entwicklung bei, der eine Exception wirft, wenn Lazy Loading auftritt, und hilft so, N+1 Probleme frühzeitig zu erkennen.

F: Erklären Sie den Unterschied zwischen hasOne, hasMany, belongsTo und belongsToMany.

Beziehung	Fremdschlüssel-Position	Beispiel
hasOne	Im zugehörigen Model	User hasOne Profile (profiles.user_id)
hasMany	Im zugehörigen Model	User hasMany Posts (posts.user_id)
belongsTo	Im aktuellen Model	Post belongsTo User (posts.user_id)
belongsToMany	Pivot-Tabelle	User belongsToMany Roles (role_user Tabelle)

F: Wie werden Soft Deletes gehandhabt und welche Auswirkungen haben sie?

app/Models/Post.phpphp

use Illuminate\Database\Eloquent\SoftDeletes;

class Post extends Model
{
    use SoftDeletes;
    
    // Soft-deleted Datensätze werden standardmäßig ausgeschlossen
    // Um sie einzuschließen:
    // Post::withTrashed()->get();
    // Nur gelöschte abrufen:
    // Post::onlyTrashed()->get();
}

Soft Deletes fügen eine deleted_at Spalte hinzu. Queries schließen soft-deleted Datensätze automatisch aus, es sei denn, sie werden explizit angefordert. Dies beeinflusst Unique Constraints und erfordert zusammengesetzte Indizes, die deleted_at für optimale Performance einschließen.

Service Container und Dependency Injection

Der Service Container ist das Herzstück von Laravel. Das Verständnis von Binding, Resolution und kontextbezogener Injection unterscheidet erfahrene Entwickler von Anfängern.

F: Was ist der Unterschied zwischen bind() und singleton() im Service Container?

app/Providers/AppServiceProvider.phpphp

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

public function register(): void
{
    // bind() erstellt jedes Mal eine neue Instanz
    $this->app->bind(PaymentGateway::class, function ($app) {
        return new StripeGateway(config('services.stripe.key'));
    });
    
    // singleton() erstellt einmal und verwendet dieselbe Instanz wieder
    $this->app->singleton(PaymentGateway::class, function ($app) {
        return new StripeGateway(config('services.stripe.key'));
    });
}

bind() erstellt bei jeder Resolution eine frische Instanz, während singleton() die Instanz für die gesamte Lebensdauer der Anfrage zwischenspeichert. Singleton sollte für zustandslose Services oder Ressourcen verwendet werden, die teuer zu instanziieren sind.

F: Wie funktioniert 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 ermöglicht verschiedene Implementierungen basierend auf der konsumierenden Klasse, ohne mehrere Interfaces oder Service Locator Patterns zu erfordern.

Authentifizierung und Autorisierung

Laravel 13 führt native Passkey-Unterstützung ein, während das bestehende Authentifizierungssystem beibehalten wird. Interviewfragen testen oft das Verständnis beider Ansätze.

F: Vergleichen Sie Gates und Policies für die Autorisierung.

app/Providers/AppServiceProvider.phpphp

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

public function boot(): void
{
    // Gate: Einfache Closure-basierte Prüfung
    Gate::define('update-post', function (User $user, Post $post) {
        return $user->id === $post->user_id;
    });
}

// app/Policies/PostPolicy.php
class PostPolicy
{
    // Policy: Klassenmethoden für komplexe Autorisierung
    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 eignen sich für einfache, einmalige Prüfungen. Policies organisieren Autorisierungslogik nach Model und integrieren sich automatisch in Controller-Methoden über Model Binding.

F: Wie implementiert man Rate Limiting für 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()
        );
    });
    
    // Gestaffeltes Limiting für Premium-Nutzer
    RateLimiter::for('uploads', function ($request) {
        return $request->user()?->isPremium()
            ? Limit::perMinute(100)
            : Limit::perMinute(10);
    });
}

Bereit für deine Laravel-Interviews?

Übe mit unseren interaktiven Simulatoren, Flashcards und technischen Tests.

Laravel erkunden

Queues und Jobs

Hintergrundverarbeitung mit Queues ist entscheidend für skalierbare Laravel-Anwendungen. Interviewer bewerten das Verständnis von Job-Design, Fehlerbehandlung und Monitoring.

F: Was ist der Unterschied zwischen dispatch() und dispatchSync()?

app/Http/Controllers/OrderController.phpphp

use App\Jobs\ProcessOrder;

public function store(Request $request)
{
    $order = Order::create($request->validated());
    
    // Asynchron: Job wird in Queue gestellt
    ProcessOrder::dispatch($order);
    
    // Synchron: Job wird sofort in derselben Anfrage ausgeführt
    ProcessOrder::dispatchSync($order);
    
    // Nach Antwort: Wird nach Senden der HTTP-Antwort ausgeführt
    ProcessOrder::dispatchAfterResponse($order);
}

dispatch() stellt Jobs zur späteren Verarbeitung durch Worker in die Queue. dispatchSync() führt sofort aus und ist nützlich zum Testen oder wenn Ergebnisse sofort benötigt werden. dispatchAfterResponse() verzögert die Ausführung bis nach Abschluss der HTTP-Antwort.

F: Wie werden fehlgeschlagene Jobs behandelt?

app/Jobs/ProcessPayment.phpphp

class ProcessPayment implements ShouldQueue
{
    use Dispatchable, InteractsWithQueue, Queueable, SerializesModels;
    
    public int $tries = 3;
    public int $backoff = 60; // Sekunden zwischen Versuchen
    public int $timeout = 120;
    
    public function handle(): void
    {
        // Verarbeitungslogik
    }
    
    public function failed(\Throwable $exception): void
    {
        // Benachrichtigung senden, Fehler loggen etc.
        Log::error('Zahlungsverarbeitung fehlgeschlagen', [
            'order_id' => $this->order->id,
            'error' => $exception->getMessage(),
        ]);
    }
    
    public function retryUntil(): DateTime
    {
        return now()->addHours(24);
    }
}

Laravel bietet automatische Wiederholungen, exponentielles Backoff und eine Tabelle für fehlgeschlagene Jobs. Die failed() Methode ermöglicht benutzerdefinierte Fehlerbehandlung wie Benachrichtigungen oder kompensatorische Transaktionen.

Testing-Strategien

Laravel-Tests umfassen Unit Tests, Feature Tests und Browser Tests. Interviewer erwarten Verständnis aller drei Ebenen.

F: Wie werden Datenbank-Abhängigkeiten in Tests behandelt?

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' => 'Mein erster Beitrag',
            'content' => 'Beitragsinhalt hier',
        ]);
        
        $response->assertRedirect('/posts');
        $this->assertDatabaseHas('posts', [
            'title' => 'Mein erster Beitrag',
            'user_id' => $user->id,
        ]);
    }
}

RefreshDatabase setzt die Datenbank zwischen Tests zurück und verwendet Transaktionen für Geschwindigkeit. Für große Test-Suiten ist LazilyRefreshDatabase nur bei Bedarf zu migrieren.

F: Wie werden externe APIs in Tests gemockt?

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']);
}

Architektur und Best Practices

Senior-Positionen erfordern architektonische Entscheidungsfähigkeit und Verständnis der Laravel-Ökosystem-Konventionen.

F: Wann sollten Events und Listeners gegenüber direkten Service-Aufrufen verwendet werden?

Events entkoppeln Actions von ihren Nebeneffekten. Ein UserRegistered Event kann mehrere Listener auslösen: E-Mail senden, Analytics loggen, Slack benachrichtigen. Jeder Listener kann in die Queue gestellt werden und unabhängig fehlschlagen.

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());
    }
}

Direkte Service-Aufrufe sind angemessen, wenn die Action einen Rückgabewert erfordert oder wenn es nur einen Konsumenten gibt.

F: Erklären Sie das Repository Pattern in Laravel-Anwendungen.

Das Repository Pattern abstrahiert Datenzugriffslogik von Business-Logik. Während Eloquent bereits Abstraktion bietet, fügen Repositories eine weitere Schicht für testbare, austauschbare Implementierungen hinzu.

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();
    }
}

Die Laravel-Community diskutiert dieses Pattern. Manche argumentieren, dass Eloquent Models bereits Repositories sind. Andere bevorzugen die zusätzliche Testbarkeit und die Fähigkeit, Implementierungen zu wechseln.

Laravel 13 Neue Features

Interviewer erwarten Kenntnis aktueller Framework-Änderungen und deren praktische Anwendungen.

F: Was ist das neue AI SDK in Laravel 13?

Laravel 13 führt ein First-Party AI SDK ein, das mehrere LLM-Provider hinter einer einheitlichen API abstrahiert.

config/ai.php konfiguriert Providerphp

use Illuminate\Support\Facades\AI;

$response = AI::chat()
    ->system('Du bist ein hilfreicher Assistent.')
    ->user('Erkläre Dependency Injection.')
    ->generate();

// Streaming-Unterstützung
AI::chat()
    ->user('Schreibe ein Gedicht über Laravel.')
    ->stream(function (string $chunk) {
        echo $chunk;
    });

Das SDK unterstützt OpenAI, Anthropic und lokale Modelle über Ollama. Es verwaltet API-Schlüssel, Wiederholungsversuche und Antwortparsing automatisch.

F: Wie funktionieren PHP Attributes für 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
    {
        // User erstellen
    }
}

Attribute-basiertes Routing koexistiert mit traditionellen Routendateien. Es bringt Routendefinitionen näher an Controller-Methoden und macht den Code selbstdokumentierend.

Fazit

Die Vorbereitung auf Laravel-Interviews erfordert sowohl theoretisches Verständnis als auch praktische Erfahrung. Die behandelten Fragen bilden eine solide Grundlage, aber Interviewer werden tiefer in Bereiche vordringen, die spezifisch für ihre Projekte sind. Regelmäßiges Üben mit Laravel-Projekten, das Lesen des Framework-Quellcodes und das Verfolgen der offiziellen Release Notes festigt das Wissen. Der beste Weg, ein Laravel-Interview zu bestehen, ist der Aufbau echter Anwendungen und das tiefe Verständnis der Muster, die das Framework implementiert.