# Preguntas de entrevista para desarrollador PHP Laravel 2026: Guía completa de preparación

> Las preguntas de entrevista para desarrollador PHP Laravel evalúan tanto el conocimiento del framework como los principios de diseño de software. Con Laravel 13 lanzado en marzo de 2026, los entrevistadores esperan que los candidatos demuestren conocimiento de las funcionalidades actuales junto con los fundamentos.

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

---

Las preguntas de entrevista para desarrollador PHP Laravel evalúan tanto el conocimiento del framework como los principios de diseño de software. Con Laravel 13 lanzado en marzo de 2026 introduciendo el SDK de IA, PHP Attributes y autenticación Passkey, los entrevistadores esperan que los candidatos demuestren conocimiento de las funcionalidades actuales además de los fundamentos del framework.

> **Áreas de enfoque en entrevistas**
>
> Las entrevistas de Laravel típicamente cubren cinco pilares: relaciones Eloquent ORM y rendimiento, Service Container e inyección de dependencias, patrones de autenticación y autorización, manejo de colas y jobs, y estrategias de testing. Los roles senior añaden decisiones de arquitectura y conocimiento del ecosistema de paquetes.

## Eloquent ORM y preguntas sobre bases de datos

Eloquent sigue siendo el tema más discutido en entrevistas de Laravel. Los entrevistadores evalúan si los candidatos entienden lazy loading vs eager loading, tipos de relaciones y optimización de consultas.

**P: ¿Qué es el problema N+1 y cómo lo resuelve Laravel?**

El problema N+1 ocurre cuando el código ejecuta una consulta para obtener una colección, luego N consultas adicionales para cargar datos relacionados de cada elemento. Laravel proporciona eager loading mediante `with()` para resolver esto.

```php
// app/Http/Controllers/PostController.php
// Problema N+1: 1 consulta para posts + N consultas para autores
$posts = Post::all();
foreach ($posts as $post) {
    echo $post->author->name; // Dispara una consulta por post
}

// Solución: Eager load con with()
$posts = Post::with('author')->get(); // 2 consultas en total
foreach ($posts as $post) {
    echo $post->author->name; // Sin consulta adicional
}
```

Laravel 13 mantiene el modo estricto en desarrollo, que lanza una excepción cuando ocurre lazy loading, ayudando a detectar problemas N+1 tempranamente.

**P: Explica la diferencia entre `hasOne`, `hasMany`, `belongsTo` y `belongsToMany`.**

| Relación | Ubicación de la clave foránea | Ejemplo |
|----------|------------------------------|----------|
| hasOne | En el modelo relacionado | User hasOne Profile (profiles.user_id) |
| hasMany | En el modelo relacionado | User hasMany Posts (posts.user_id) |
| belongsTo | En el modelo actual | Post belongsTo User (posts.user_id) |
| belongsToMany | Tabla pivote | User belongsToMany Roles (tabla role_user) |

**P: ¿Cómo se manejan los soft deletes y cuáles son las implicaciones?**

```php
// app/Models/Post.php
use Illuminate\Database\Eloquent\SoftDeletes;

class Post extends Model
{
    use SoftDeletes;
    
    // Los registros soft-deleted se excluyen por defecto
    // Para incluirlos:
    // Post::withTrashed()->get();
    // Para obtener solo los eliminados:
    // Post::onlyTrashed()->get();
}
```

Los soft deletes añaden una columna `deleted_at`. Las consultas automáticamente excluyen registros soft-deleted a menos que se solicite explícitamente. Esto afecta las restricciones de unicidad y requiere índices compuestos que incluyan `deleted_at` para un rendimiento óptimo.

## Service Container e inyección de dependencias

El [Service Container](https://laravel.com/docs/13.x/container) es el núcleo de Laravel. Entender binding, resolución e inyección contextual separa a los candidatos junior de los senior.

**P: ¿Qué es el Service Container y por qué es importante?**

El Service Container gestiona las dependencias de las clases y realiza inyección de dependencias. Resuelve clases automáticamente, habilitando un acoplamiento débil y testeabilidad.

```php
// app/Providers/AppServiceProvider.php
public function register(): void
{
    // Binding de interfaz
    $this->app->bind(
        PaymentGatewayInterface::class,
        StripePaymentGateway::class
    );
    
    // Singleton: misma instancia cada vez
    $this->app->singleton(ReportGenerator::class, function ($app) {
        return new ReportGenerator($app->make(Cache::class));
    });
}
```

**P: ¿Cuál es la diferencia entre `bind()`, `singleton()` e `instance()`?**

- `bind()`: Crea una nueva instancia cada vez que se resuelve la clase
- `singleton()`: Crea una instancia y devuelve la misma instancia en resoluciones posteriores
- `instance()`: Vincula una instancia de objeto existente al container

```php
// app/Providers/AppServiceProvider.php
// bind: nueva instancia cada vez
$this->app->bind(Service::class, fn() => new Service());

// singleton: una instancia para todo el ciclo de vida de la solicitud
$this->app->singleton(Cache::class, fn() => new RedisCache());

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

Para practicar conceptos del Service Container, consulta el [módulo Service Container & DI](/technologies/laravel/interview-questions/service-container-di).

## Patrones de autenticación y autorización

Laravel 13 introdujo autenticación Passkey junto a los métodos existentes. Los entrevistadores esperan conocimiento de Sanctum, Passport, policies y gates.

**P: ¿Cuándo usar Sanctum vs Passport?**

| Característica | Sanctum | Passport |
|----------------|---------|----------|
| Caso de uso | SPA, apps móviles, tokens API simples | Servidor OAuth2, acceso de terceros |
| Tipo de token | Tokens API simples, basado en sesión | Tokens de acceso OAuth2, refresh tokens |
| Complejidad | Configuración mínima | Implementación OAuth2 completa |
| Scopes de token | Abilities (más simple) | Scopes OAuth |

Sanctum se adapta a la mayoría de aplicaciones. Passport es necesario cuando la aplicación debe actuar como proveedor OAuth2 para clientes de terceros. Ver la comparación detallada en [Laravel Sanctum vs Passport](/blog/laravel/laravel-sanctum-vs-passport-api-authentication).

**P: ¿En qué se diferencian las policies de los gates?**

Los gates son verificaciones de autorización basadas en closures. Las policies son clases que agrupan la lógica de autorización para un 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 en el controlador
public function update(Request $request, Post $post)
{
    $this->authorize('update', $post); // Usa PostPolicy
    // ... lógica de actualización
}
```

El [módulo Autorización & Policies](/technologies/laravel/interview-questions/authorization-policies) cubre patrones de autorización avanzados.

## Colas y procesamiento de jobs

Las colas son esenciales para aplicaciones Laravel escalables. Los entrevistadores sondean el entendimiento del diseño de jobs, manejo de fallos y drivers de cola.

**P: ¿Cómo se manejan los jobs fallidos en Laravel?**

```php
// app/Jobs/ProcessPodcast.php
class ProcessPodcast implements ShouldQueue
{
    use Queueable;
    
    public int $tries = 3;
    public int $backoff = 60; // segundos entre reintentos
    public int $timeout = 120;
    
    public function handle(): void
    {
        // Lógica del job
    }
    
    public function failed(Throwable $exception): void
    {
        // Notificar al admin, registrar en servicio externo
        Log::error('Fallo en procesamiento de podcast', [
            'podcast_id' => $this->podcast->id,
            'error' => $exception->getMessage()
        ]);
    }
}
```

Los jobs fallidos se almacenan en la tabla `failed_jobs`. Se utiliza `php artisan queue:retry` para reintentar jobs específicos o `queue:retry all` para reintento masivo.

**P: ¿Cuál es la diferencia entre `dispatch()` y `dispatchSync()`?**

- `dispatch()`: Envía el job a la cola para procesamiento asíncrono
- `dispatchSync()`: Ejecuta el job inmediatamente en el proceso actual, saltando la cola

`dispatchSync()` es útil para testing o cuando el resultado se necesita inmediatamente. En producción, la mayoría de jobs deberían usar `dispatch()` para evitar bloquear la solicitud.

## Testing en Laravel con Pest

Laravel 13 viene con [Pest](https://pestphp.com/) como framework de testing por defecto. Los entrevistadores evalúan el entendimiento de tests de funcionalidad, tests unitarios, mocking y estrategias de testing de base de datos.

**P: ¿Cómo se testea un controlador que depende de una API externa?**

```php
// tests/Feature/PaymentTest.php
use App\Services\PaymentGateway;
use App\Services\FakePaymentGateway;

test('el pago se procesa exitosamente', function () {
    // Vincular implementación falsa para testing
    $this->app->bind(
        PaymentGateway::class,
        FakePaymentGateway::class
    );
    
    $response = $this->postJson('/api/payments', [
        'amount' => 1000,
        'currency' => 'usd'
    ]);
    
    $response->assertStatus(200)
        ->assertJson(['status' => 'completed']);
});

test('el pago maneja errores de gateway', function () {
    $mock = Mockery::mock(PaymentGateway::class);
    $mock->shouldReceive('charge')
        ->once()
        ->andThrow(new PaymentFailedException('Tarjeta rechazada'));
    
    $this->app->instance(PaymentGateway::class, $mock);
    
    $response = $this->postJson('/api/payments', [
        'amount' => 1000,
        'currency' => 'usd'
    ]);
    
    $response->assertStatus(422);
});
```

**P: ¿Cuál es la diferencia entre `RefreshDatabase` y `DatabaseTransactions`?**

- `RefreshDatabase`: Migra la base de datos una vez por clase de test, envuelve cada test en una transacción
- `DatabaseTransactions`: Asume que la base de datos ya está migrada, envuelve cada test en una transacción

`RefreshDatabase` es más seguro para pipelines CI/CD. `DatabaseTransactions` es más rápido para desarrollo local cuando el esquema es estable.

Para mejores prácticas de testing, consulta [Testing en Laravel con Pest](/blog/laravel/laravel-testing-pest-mocking-best-practices).

## Preguntas específicas de Laravel 13

Los entrevistadores preguntan cada vez más sobre funcionalidades de Laravel 13 anunciadas en [Laracon EU 2026](https://laraveldaily.com/post/laravel-13-laracon-eu-taylor-otwell).

**P: ¿Qué es el SDK de IA de Laravel y cuándo usarlo?**

El [SDK de IA de Laravel](https://laravel.com/docs/13.x/ai) proporciona una API unificada para operaciones de IA: generación de texto, embeddings, agentes con llamada a herramientas, audio y generación de imágenes. Abstrae las diferencias entre proveedores como OpenAI, Anthropic y otros.

```php
// config/ai.php define el proveedor por defecto
// Uso en código de aplicación
use Illuminate\Support\Facades\AI;

$response = AI::text('Resume este artículo para una audiencia de desarrolladores')
    ->withContext($articleContent)
    ->generate();

// Embeddings para búsqueda semántica
$embedding = AI::embeddings($searchQuery)->generate();
$results = Post::query()
    ->nearestNeighbors('embedding', $embedding, 10)
    ->get();
```

El SDK es apropiado para aplicaciones que requieren funcionalidades de IA sin gestionar múltiples SDKs de proveedores.

**P: ¿Cómo funcionan los PHP Attributes en Laravel 13?**

Laravel 13 introdujo PHP 8 Attributes como alternativa a las propiedades de clase para configuración de componentes. No es un cambio disruptivo: la configuración basada en propiedades continúa funcionando.

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

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

#[Queue('emails')]
#[Tries(3)]
class SendWelcomeEmail implements ShouldQueue
{
    // Cuerpo de clase más limpio
}
```

Los Attributes proporcionan mejor soporte de IDE y mantienen la configuración visible a nivel de definición de clase.

## Puntos clave para entrevistas Laravel en 2026

- Dominar eager loading de Eloquent con `with()` y entender el modo estricto que detecta consultas N+1 en desarrollo
- Explicar bindings del Service Container: `bind()` para transitorio, `singleton()` para instancias compartidas, binding contextual para resolución de interfaces
- Saber cuándo usar Sanctum vs Passport: Sanctum para apps propias, Passport para escenarios de proveedor OAuth2
- Demostrar manejo de fallos de cola con `$tries`, `$backoff` y el método `failed()`
- Escribir tests con Pest, usar mocks para dependencias externas y entender la diferencia entre `RefreshDatabase` y `DatabaseTransactions`
- Estar familiarizado con funcionalidades de Laravel 13: SDK de IA para operaciones de IA unificadas, PHP Attributes para configuración de componentes más limpia, y autenticación Passkey
- Practicar explicando trade-offs, no solo implementaciones: los entrevistadores valoran el razonamiento sobre la memorización

---

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