# 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, os entrevistadores esperam que os candidatos demonstrem conhecimento das funcionalidades atuais junto com os fundamentos.

- Published: 2026-09-07
- Updated: 2026-09-07
- Author: Anthony Fillion-Maillet
- Reading time: 5 min

---

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.

> **Áreas de foco nas entrevistas**
>
> As entrevistas de Laravel tipicamente cobrem cinco pilares: relacionamentos Eloquent ORM e performance, Service Container e injeção de dependências, padrões de autenticação e autorização, gerenciamento de filas e jobs, e estratégias de testes. Cargos seniores adicionam decisões de arquitetura e conhecimento do ecossistema de pacotes.

## 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.

```php
// app/Http/Controllers/PostController.php
// 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`.**

| Relacionamento | Localização da chave estrangeira | Exemplo |
|----------------|----------------------------------|----------|
| hasOne | No modelo relacionado | User hasOne Profile (profiles.user_id) |
| hasMany | No modelo relacionado | User hasMany Posts (posts.user_id) |
| belongsTo | No modelo atual | Post belongsTo User (posts.user_id) |
| belongsToMany | Tabela pivô | User belongsToMany Roles (tabela role_user) |

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

```php
// app/Models/Post.php
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](https://laravel.com/docs/13.x/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.

```php
// app/Providers/AppServiceProvider.php
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

```php
// app/Providers/AppServiceProvider.php
// 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](/technologies/laravel/interview-questions/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?**

| Característica | Sanctum | Passport |
|----------------|---------|----------|
| Caso de uso | SPA, apps móveis, tokens API simples | Servidor OAuth2, acesso de terceiros |
| Tipo de token | Tokens API simples, baseado em sessão | Tokens de acesso OAuth2, refresh tokens |
| Complexidade | Configuração mínima | Implementação OAuth2 completa |
| Scopes de token | Abilities (mais simples) | Scopes OAuth |

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](/blog/laravel/laravel-sanctum-vs-passport-api-authentication).

**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.

```php
// app/Policies/PostPolicy.php
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](/technologies/laravel/interview-questions/authorization-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?**

```php
// app/Jobs/ProcessPodcast.php
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](https://pestphp.com/) 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?**

```php
// tests/Feature/PaymentTest.php
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](/blog/laravel/laravel-testing-pest-mocking-best-practices).

## Perguntas específicas do Laravel 13

Os entrevistadores perguntam cada vez mais sobre funcionalidades do Laravel 13 anunciadas na [Laracon EU 2026](https://laraveldaily.com/post/laravel-13-laracon-eu-taylor-otwell).

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

O [SDK de IA do Laravel](https://laravel.com/docs/13.x/ai) 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.

```php
// config/ai.php define o provedor padrão
// 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.

```php
// 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

---

Source: SharpSkill (https://sharpskill.dev), tech interview preparation for your real stack.
HTML version of this page: https://sharpskill.dev/pt/blog/laravel/php-laravel-developer-interview-questions-2026