Laravel Specialist

Laravel Specialist is a community skill for building web applications with the Laravel PHP framework, covering routing, Eloquent ORM, middleware, Blade templates, and API development for modern PHP projects.

What Is This?

Overview

Laravel Specialist provides patterns for developing production web applications using Laravel. It covers route definition with controllers, resource routing, and route model binding for clean URL handling, Eloquent ORM relationships including hasMany, belongsTo, and polymorphic associations for database modeling, middleware pipelines for authentication, rate limiting, and request transformation, Blade template engine with components, layouts, and slots for reusable view rendering, and Artisan command creation for custom CLI tooling and task scheduling. The skill enables PHP developers to follow Laravel conventions for building maintainable applications with expressive, readable syntax and strong ecosystem support.

Who Should Use This

This skill serves PHP developers building web applications and APIs with Laravel, backend engineers designing database-driven applications using Eloquent ORM, and teams adopting Laravel for new projects or maintaining existing Laravel codebases.

Why Use It?

Problems It Solves

Structuring PHP applications with proper separation of routing, business logic, and data access requires a consistent framework. Building database queries that handle relationships and eager loading efficiently needs ORM expertise. Implementing authentication with role-based access control demands integration with Laravel built-in auth scaffolding. Creating reusable view components that maintain consistency across pages requires template organization.

Core Highlights

Eloquent models define relationships and scopes for expressive database queries. Resource controllers generate CRUD endpoints with standardized route naming. Form request classes handle validation rules separately from controller logic. Queue workers process background jobs with retry and failure handling.

How to Use It?

Basic Usage

// app/Models/Post.php
namespace App\Models;

use Illuminate\Database\Eloquent\Model;
use Illuminate\Database\Eloquent\Relations\BelongsTo;
use Illuminate\Database\Eloquent\Relations\HasMany;

class Post extends Model
{
    protected $fillable = [
        'title', 'slug', 'body',
        'user_id', 'published_at',
    ];

    protected $casts = [
        'published_at' => 'datetime',
    ];

    public function author(): BelongsTo
    {
        return $this->belongsTo(
            User::class, 'user_id');
    }

    public function comments(): HasMany
    {
        return $this->hasMany(
            Comment::class);
    }

    public function scopePublished($query)
    {
        return $query->whereNotNull(
            'published_at')
            ->where('published_at',
                    '<=', now());
    }
}

// Usage
$posts = Post::published()
    ->with(['author', 'comments'])
    ->orderBy('published_at', 'desc')
    ->paginate(15);

Real-World Examples

// app/Http/Controllers/Api/PostController.php
namespace App\Http\Controllers\Api;

use App\Http\Controllers\Controller;
use App\Http\Requests\StorePostRequest;
use App\Http\Resources\PostResource;
use App\Models\Post;
use Illuminate\Http\Request;

class PostController extends Controller
{
    public function index(Request $request)
    {
        $posts = Post::published()
            ->with('author')
            ->when($request->search,
                fn($q, $s) => $q->where(
                    'title', 'like',
                    "%{$s}%"))
            ->paginate(20);
        return PostResource::collection(
            $posts);
    }

    public function store(
        StorePostRequest $request)
    {
        $post = $request->user()
            ->posts()->create(
                $request->validated());
        return new PostResource($post);
    }

    public function show(Post $post)
    {
        $post->load([
            'author',
            'comments.user']);
        return new PostResource($post);
    }

    public function destroy(Post $post)
    {
        $this->authorize('delete', $post);
        $post->delete();
        return response()->noContent();
    }
}

Advanced Tips

Use query scopes to encapsulate common filtering logic that is reused across controllers and API endpoints. Implement observer classes to handle model lifecycle events like creating slugs or clearing caches on updates. Use Laravel Horizon to monitor Redis queues and track job throughput and failure rates in production.

When to Use It?

Use Cases

Build a content management API with Eloquent resources, pagination, and full-text search filtering. Create a SaaS application with multi-tenancy using database scoping and middleware. Implement a task queue system with scheduled jobs and event-driven notifications for background processing workflows.

Related Topics

PHP web development, Eloquent ORM, REST API design, queue processing, and MVC architecture.

Important Notes

Requirements

PHP 8.1 or later with Laravel installed via Composer. A supported database such as MySQL, PostgreSQL, or SQLite. Redis for queue and cache functionality in production environments.

Usage Recommendations

Do: use eager loading with the with method to prevent N+1 query problems when accessing relationships. Define form request classes for validation rules instead of validating inline in controllers. Use database transactions for operations that modify multiple tables atomically.

Don't: put business logic directly in controllers when it should be in service classes or model methods. Use raw queries when Eloquent query builder can express the same operation. Skip writing database migrations and modify tables manually in production.

Limitations

Eloquent ORM adds overhead compared to raw queries for very high-throughput database operations. Laravel monolithic structure can become unwieldy for very large applications without careful modular organization. Real-time features require additional infrastructure like Laravel Echo and Pusher or WebSocket servers.