Le domande per colloqui PHP Laravel developer testano sia la conoscenza del framework che i principi di design del software. Con Laravel 13 rilasciato a marzo 2026, che introduce l'AI SDK, PHP Attributes e autenticazione Passkey, gli intervistatori si aspettano che i candidati dimostrino consapevolezza delle funzionalità attuali insieme ai fondamentali.

Aree di Focus del Colloquio

I colloqui Laravel coprono tipicamente cinque pilastri: relazioni Eloquent ORM e performance, Service Container e dependency injection, pattern di autenticazione e autorizzazione, gestione di code e job, e strategie di testing. I ruoli senior aggiungono decisioni architetturali e conoscenza dell'ecosistema dei pacchetti.

Eloquent ORM e Domande sul Database

Eloquent rimane l'argomento più discusso nei colloqui Laravel. Gli intervistatori valutano se i candidati comprendono lazy vs eager loading, tipi di relazioni e ottimizzazione delle query.

D: Cos'è il problema N+1 query e come lo risolve Laravel?

Il problema N+1 si verifica quando il codice esegue una query per recuperare una collezione, poi N query aggiuntive per caricare i dati correlati per ogni elemento. Laravel fornisce l'eager loading tramite with() per risolvere questo problema.

app/Http/Controllers/PostController.phpphp

// Problema N+1: 1 query per i post + N query per gli autori
$posts = Post::all();
foreach ($posts as $post) {
    echo $post->author->name; // Attiva una query per post
}

// Soluzione: Eager load con with()
$posts = Post::with('author')->get(); // 2 query in totale
foreach ($posts as $post) {
    echo $post->author->name; // Nessuna query aggiuntiva
}

Laravel 13 mantiene la strict mode in sviluppo, che lancia un'eccezione quando si verifica il lazy loading, aiutando a identificare i problemi N+1 precocemente.

D: Spiega la differenza tra hasOne, hasMany, belongsTo e belongsToMany.

Relazione	Posizione Foreign Key	Esempio
hasOne	Nel model correlato	User hasOne Profile (profiles.user_id)
hasMany	Nel model correlato	User hasMany Posts (posts.user_id)
belongsTo	Nel model corrente	Post belongsTo User (posts.user_id)
belongsToMany	Tabella pivot	User belongsToMany Roles (tabella role_user)

D: Come si gestiscono i soft delete e quali sono le implicazioni?

app/Models/Post.phpphp

use Illuminate\Database\Eloquent\SoftDeletes;

class Post extends Model
{
    use SoftDeletes;
    
    // I record soft-deleted sono esclusi di default
    // Per includerli:
    // Post::withTrashed()->get();
    // Per ottenere solo i cancellati:
    // Post::onlyTrashed()->get();
}

I soft delete aggiungono una colonna deleted_at. Le query escludono automaticamente i record soft-deleted a meno che non siano esplicitamente richiesti. Questo influisce sui vincoli unique e richiede indici composti che includano deleted_at per prestazioni ottimali.

Service Container e Dependency Injection

Il Service Container è il cuore di Laravel. La comprensione di binding, risoluzione e injection contestuale distingue gli sviluppatori esperti dai principianti.

D: Qual è la differenza tra bind() e singleton() nel Service Container?

app/Providers/AppServiceProvider.phpphp

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

public function register(): void
{
    // bind() crea una nuova istanza ogni volta
    $this->app->bind(PaymentGateway::class, function ($app) {
        return new StripeGateway(config('services.stripe.key'));
    });
    
    // singleton() crea una volta e riutilizza la stessa istanza
    $this->app->singleton(PaymentGateway::class, function ($app) {
        return new StripeGateway(config('services.stripe.key'));
    });
}

bind() crea un'istanza fresca ad ogni risoluzione, mentre singleton() memorizza nella cache l'istanza per l'intera durata della richiesta. Il singleton dovrebbe essere usato per servizi stateless o risorse costose da istanziare.

D: Come funziona il 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);
}

Il contextual binding permette implementazioni diverse basate sulla classe consumatrice, senza richiedere interfacce multiple o pattern Service Locator.

Autenticazione e Autorizzazione

Laravel 13 introduce il supporto nativo per Passkey mantenendo il sistema di autenticazione esistente. Le domande dei colloqui spesso testano la comprensione di entrambi gli approcci.

D: Confronta Gates e Policies per l'autorizzazione.

app/Providers/AppServiceProvider.phpphp

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

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

// app/Policies/PostPolicy.php
class PostPolicy
{
    // Policy: Metodi di classe per autorizzazione complessa
    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');
    }
}

I Gates sono adatti per controlli semplici e una tantum. Le Policies organizzano la logica di autorizzazione per Model e si integrano automaticamente con i metodi del controller tramite il Model binding.

D: Come si implementa il Rate Limiting per le API?

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()
        );
    });
    
    // Limiting differenziato per utenti premium
    RateLimiter::for('uploads', function ($request) {
        return $request->user()?->isPremium()
            ? Limit::perMinute(100)
            : Limit::perMinute(10);
    });
}

Pronto a superare i tuoi colloqui su Laravel?

Pratica con i nostri simulatori interattivi, flashcards e test tecnici.

Esplora Laravel

Code e Jobs

L'elaborazione in background con le code è fondamentale per applicazioni Laravel scalabili. Gli intervistatori valutano la comprensione del design dei job, gestione degli errori e monitoraggio.

D: Qual è la differenza tra dispatch() e dispatchSync()?

app/Http/Controllers/OrderController.phpphp

use App\Jobs\ProcessOrder;

public function store(Request $request)
{
    $order = Order::create($request->validated());
    
    // Asincrono: Il job viene messo in coda
    ProcessOrder::dispatch($order);
    
    // Sincrono: Il job viene eseguito immediatamente nella stessa richiesta
    ProcessOrder::dispatchSync($order);
    
    // Dopo la risposta: Eseguito dopo l'invio della risposta HTTP
    ProcessOrder::dispatchAfterResponse($order);
}

dispatch() mette i job in coda per l'elaborazione successiva da parte dei worker. dispatchSync() esegue immediatamente ed è utile per il testing o quando i risultati sono necessari subito. dispatchAfterResponse() ritarda l'esecuzione fino al completamento della risposta HTTP.

D: Come si gestiscono i job falliti?

app/Jobs/ProcessPayment.phpphp

class ProcessPayment implements ShouldQueue
{
    use Dispatchable, InteractsWithQueue, Queueable, SerializesModels;
    
    public int $tries = 3;
    public int $backoff = 60; // Secondi tra i tentativi
    public int $timeout = 120;
    
    public function handle(): void
    {
        // Logica di elaborazione
    }
    
    public function failed(\Throwable $exception): void
    {
        // Invia notifica, logga errore ecc.
        Log::error('Elaborazione pagamento fallita', [
            'order_id' => $this->order->id,
            'error' => $exception->getMessage(),
        ]);
    }
    
    public function retryUntil(): DateTime
    {
        return now()->addHours(24);
    }
}

Laravel fornisce retry automatici, backoff esponenziale e una tabella per i job falliti. Il metodo failed() permette gestione personalizzata degli errori come notifiche o transazioni compensative.

Strategie di Testing

I test Laravel comprendono unit test, feature test e browser test. Gli intervistatori si aspettano comprensione di tutti e tre i livelli.

D: Come si gestiscono le dipendenze dal database nei test?

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' => 'Il mio primo post',
            'content' => 'Contenuto del post qui',
        ]);
        
        $response->assertRedirect('/posts');
        $this->assertDatabaseHas('posts', [
            'title' => 'Il mio primo post',
            'user_id' => $user->id,
        ]);
    }
}

RefreshDatabase resetta il database tra i test usando transazioni per velocità. Per suite di test grandi, LazilyRefreshDatabase migra solo quando necessario.

D: Come si mockano le API esterne nei test?

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

Architettura e Best Practices

I ruoli senior richiedono capacità decisionali architetturali e comprensione delle convenzioni dell'ecosistema Laravel.

D: Quando si dovrebbero usare Events e Listeners rispetto alle chiamate dirette ai service?

Gli eventi disaccoppiano le azioni dai loro effetti collaterali. Un evento UserRegistered può attivare più listener: inviare email, loggare analytics, notificare Slack. Ogni listener può essere messo in coda e fallire indipendentemente.

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

Le chiamate dirette ai service sono appropriate quando l'azione richiede un valore di ritorno o quando c'è un solo consumatore.

D: Spiega il Repository Pattern nelle applicazioni Laravel.

Il Repository Pattern astrae la logica di accesso ai dati dalla logica di business. Mentre Eloquent fornisce già astrazione, i repository aggiungono un ulteriore livello per implementazioni testabili e intercambiabili.

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

La community Laravel dibatte su questo pattern. Alcuni sostengono che i Model Eloquent siano già repository. Altri preferiscono la testabilità aggiuntiva e la capacità di cambiare implementazioni.

Nuove Funzionalità di Laravel 13

Gli intervistatori si aspettano conoscenza delle modifiche recenti al framework e delle loro applicazioni pratiche.

D: Cos'è il nuovo AI SDK in Laravel 13?

Laravel 13 introduce un AI SDK first-party che astrae più provider LLM dietro un'API unificata.

config/ai.php configura i providerphp

use Illuminate\Support\Facades\AI;

$response = AI::chat()
    ->system('Sei un assistente utile.')
    ->user('Spiega la dependency injection.')
    ->generate();

// Supporto streaming
AI::chat()
    ->user('Scrivi una poesia su Laravel.')
    ->stream(function (string $chunk) {
        echo $chunk;
    });

L'SDK supporta OpenAI, Anthropic e modelli locali tramite Ollama. Gestisce automaticamente chiavi API, retry e parsing delle risposte.

D: Come funzionano i PHP Attributes per il 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
    {
        // Crea utente
    }
}

Il routing basato su attributi coesiste con i file di route tradizionali. Porta le definizioni delle route più vicino ai metodi del controller rendendo il codice auto-documentante.

Conclusione

La preparazione per i colloqui Laravel richiede sia comprensione teorica che esperienza pratica. Le domande trattate formano una base solida, ma gli intervistatori approfondiranno aree specifiche per i loro progetti. Praticare regolarmente con progetti Laravel, leggere il codice sorgente del framework e seguire le release notes ufficiali consolida la conoscenza. Il modo migliore per superare un colloquio Laravel è costruire applicazioni reali e comprendere profondamente i pattern che il framework implementa.