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

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.

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

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

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

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

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

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?

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.

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.

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 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?

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 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?

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.

Preguntas específicas de Laravel 13

Los entrevistadores preguntan cada vez más sobre funcionalidades de Laravel 13 anunciadas en Laracon EU 2026.

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

El SDK de IA de Laravel 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.

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

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