Perguntas de entrevista para desenvolvedor PHP Laravel 2026: Guia completo de preparação

As perguntas de entrevista para desenvolvedor PHP Laravel avaliam tanto o conhecimento do framework quanto os princípios de design de software. Com o Laravel 13 lançado em março de 2026 introduzindo o SDK de IA, PHP Attributes e autenticação Passkey, os entrevistadores esperam que os candidatos demonstrem conhecimento das funcionalidades atuais além dos fundamentos do framework.

Eloquent ORM e perguntas sobre banco de dados

O Eloquent continua sendo o tópico mais discutido em entrevistas de Laravel. Os entrevistadores avaliam se os candidatos entendem lazy loading vs eager loading, tipos de relacionamentos e otimização de queries.

P: O que é o problema N+1 e como o Laravel resolve isso?

O problema N+1 ocorre quando o código executa uma query para buscar uma coleção, depois N queries adicionais para carregar dados relacionados de cada item. O Laravel fornece eager loading via with() para resolver isso.

// Problema N+1: 1 query para posts + N queries para autores
$posts = Post::all();
foreach ($posts as $post) {
    echo $post->author->name; // Dispara uma query por post
}

// Solução: Eager load com with()
$posts = Post::with('author')->get(); // 2 queries no total
foreach ($posts as $post) {
    echo $post->author->name; // Nenhuma query adicional
}

O Laravel 13 mantém o modo estrito em desenvolvimento, que lança uma exceção quando ocorre lazy loading, ajudando a detectar problemas N+1 cedo.

P: Explique a diferença entre hasOne, hasMany, belongsTo e belongsToMany.

P: Como lidar com soft deletes e quais são as implicações?

use Illuminate\Database\Eloquent\SoftDeletes;

class Post extends Model
{
    use SoftDeletes;
    
    // Registros soft-deleted são excluídos por padrão
    // Para incluí-los:
    // Post::withTrashed()->get();
    // Para obter apenas os deletados:
    // Post::onlyTrashed()->get();
}

Os soft deletes adicionam uma coluna deleted_at. As queries automaticamente excluem registros soft-deleted a menos que explicitamente solicitado. Isso afeta restrições de unicidade e requer índices compostos que incluam deleted_at para performance ótima.

Service Container e injeção de dependências

O Service Container é o núcleo do Laravel. Entender binding, resolução e injeção contextual separa candidatos junior de senior.

P: O que é o Service Container e por que ele é importante?

O Service Container gerencia dependências de classes e realiza injeção de dependências. Ele resolve classes automaticamente, habilitando baixo acoplamento e testabilidade.

public function register(): void
{
    // Binding de interface
    $this->app->bind(
        PaymentGatewayInterface::class,
        StripePaymentGateway::class
    );
    
    // Singleton: mesma instância toda vez
    $this->app->singleton(ReportGenerator::class, function ($app) {
        return new ReportGenerator($app->make(Cache::class));
    });
}

P: Qual é a diferença entre bind(), singleton() e instance()?

• bind(): Cria uma nova instância cada vez que a classe é resolvida
• singleton(): Cria uma instância e retorna a mesma instância em resoluções subsequentes
• instance(): Vincula uma instância de objeto existente ao container

// bind: nova instância cada vez
$this->app->bind(Service::class, fn() => new Service());

// singleton: uma instância para todo o ciclo de vida da requisição
$this->app->singleton(Cache::class, fn() => new RedisCache());

// instance: vincular um objeto já instanciado
$config = new Config(['debug' => true]);
$this->app->instance(Config::class, $config);

Para praticar conceitos do Service Container, consulte o módulo Service Container & DI.

Padrões de autenticação e autorização

O Laravel 13 introduziu autenticação Passkey junto aos métodos existentes. Os entrevistadores esperam conhecimento de Sanctum, Passport, policies e gates.

P: Quando usar Sanctum vs Passport?

O Sanctum se adequa à maioria das aplicações. O Passport é necessário quando a aplicação deve atuar como provedor OAuth2 para clientes de terceiros. Veja a comparação detalhada em Laravel Sanctum vs Passport.

P: Como as policies diferem dos gates?

Gates são verificações de autorização baseadas em closures. Policies são classes que agrupam lógica de autorização para um modelo específico.

class PostPolicy
{
    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');
    }
}

// Uso no controller
public function update(Request $request, Post $post)
{
    $this->authorize('update', $post); // Usa PostPolicy
    // ... lógica de atualização
}

O módulo Autorização & Policies cobre padrões de autorização avançados.

Filas e processamento de jobs

As filas são essenciais para aplicações Laravel escaláveis. Os entrevistadores sondam o entendimento do design de jobs, tratamento de falhas e drivers de fila.

P: Como tratar jobs que falharam no Laravel?

class ProcessPodcast implements ShouldQueue
{
    use Queueable;
    
    public int $tries = 3;
    public int $backoff = 60; // segundos entre tentativas
    public int $timeout = 120;
    
    public function handle(): void
    {
        // Lógica do job
    }
    
    public function failed(Throwable $exception): void
    {
        // Notificar admin, registrar em serviço externo
        Log::error('Falha no processamento do podcast', [
            'podcast_id' => $this->podcast->id,
            'error' => $exception->getMessage()
        ]);
    }
}

Jobs que falharam são armazenados na tabela failed_jobs. Use php artisan queue:retry para retentar jobs específicos ou queue:retry all para retentativa em lote.

P: Qual é a diferença entre dispatch() e dispatchSync()?

• dispatch(): Envia o job para a fila para processamento assíncrono
• dispatchSync(): Executa o job imediatamente no processo atual, ignorando a fila

dispatchSync() é útil para testes ou quando o resultado é necessário imediatamente. Em produção, a maioria dos jobs deve usar dispatch() para evitar bloquear a requisição.

Testes no Laravel com Pest

O Laravel 13 vem com Pest como framework de testes padrão. Os entrevistadores avaliam o entendimento de testes de funcionalidade, testes unitários, mocking e estratégias de teste de banco de dados.

P: Como testar um controller que depende de uma API externa?

use App\Services\PaymentGateway;
use App\Services\FakePaymentGateway;

test('o pagamento é processado com sucesso', function () {
    // Vincular implementação falsa para testes
    $this->app->bind(
        PaymentGateway::class,
        FakePaymentGateway::class
    );
    
    $response = $this->postJson('/api/payments', [
        'amount' => 1000,
        'currency' => 'usd'
    ]);
    
    $response->assertStatus(200)
        ->assertJson(['status' => 'completed']);
});

test('o pagamento trata erros do gateway', function () {
    $mock = Mockery::mock(PaymentGateway::class);
    $mock->shouldReceive('charge')
        ->once()
        ->andThrow(new PaymentFailedException('Cartão recusado'));
    
    $this->app->instance(PaymentGateway::class, $mock);
    
    $response = $this->postJson('/api/payments', [
        'amount' => 1000,
        'currency' => 'usd'
    ]);
    
    $response->assertStatus(422);
});

P: Qual é a diferença entre RefreshDatabase e DatabaseTransactions?

• RefreshDatabase: Migra o banco de dados uma vez por classe de teste, envolve cada teste em uma transação
• DatabaseTransactions: Assume que o banco de dados já está migrado, envolve cada teste em uma transação

RefreshDatabase é mais seguro para pipelines CI/CD. DatabaseTransactions é mais rápido para desenvolvimento local quando o schema é estável.

Para melhores práticas de testes, consulte Testes no Laravel com Pest.

Perguntas específicas do Laravel 13

Os entrevistadores perguntam cada vez mais sobre funcionalidades do Laravel 13 anunciadas na Laracon EU 2026.

P: O que é o SDK de IA do Laravel e quando usá-lo?

O SDK de IA do Laravel fornece uma API unificada para operações de IA: geração de texto, embeddings, agentes com chamada de ferramentas, áudio e geração de imagens. Ele abstrai as diferenças entre provedores como OpenAI, Anthropic e outros.

// Uso no código da aplicação
use Illuminate\Support\Facades\AI;

$response = AI::text('Resuma este artigo para uma audiência de desenvolvedores')
    ->withContext($articleContent)
    ->generate();

// Embeddings para busca semântica
$embedding = AI::embeddings($searchQuery)->generate();
$results = Post::query()
    ->nearestNeighbors('embedding', $embedding, 10)
    ->get();

O SDK é apropriado para aplicações que requerem funcionalidades de IA sem gerenciar múltiplos SDKs de provedores.

P: Como os PHP Attributes funcionam no Laravel 13?

O Laravel 13 introduziu PHP 8 Attributes como alternativa às propriedades de classe para configuração de componentes. Não é uma mudança disruptiva: a configuração baseada em propriedades continua funcionando.

// Abordagem tradicional
class SendWelcomeEmail implements ShouldQueue
{
    public $queue = 'emails';
    public $tries = 3;
}

// Laravel 13 com Attributes
use Illuminate\Contracts\Queue\Attributes\Queue;
use Illuminate\Contracts\Queue\Attributes\Tries;

#[Queue('emails')]
#[Tries(3)]
class SendWelcomeEmail implements ShouldQueue
{
    // Corpo da classe mais limpo
}

Os Attributes fornecem melhor suporte de IDE e mantêm a configuração visível no nível da definição da classe.

Pontos-chave para entrevistas Laravel em 2026

• Dominar eager loading do Eloquent com with() e entender o modo estrito que detecta queries N+1 em desenvolvimento
• Explicar bindings do Service Container: bind() para transitório, singleton() para instâncias compartilhadas, binding contextual para resolução de interfaces
• Saber quando usar Sanctum vs Passport: Sanctum para apps próprios, Passport para cenários de provedor OAuth2
• Demonstrar tratamento de falhas de fila com $tries, $backoff e o método failed()
• Escrever testes com Pest, usar mocks para dependências externas e entender a diferença entre RefreshDatabase e DatabaseTransactions
• Estar familiarizado com funcionalidades do Laravel 13: SDK de IA para operações de IA unificadas, PHP Attributes para configuração de componentes mais limpa, e autenticação Passkey
• Praticar explicando trade-offs, não apenas implementações: os entrevistadores valorizam raciocínio em vez de memorização