Mastering The Laravel App Service Pattern

As your Laravel application grows, keeping your code organized becomes more important than ever. A bloated controller quickly becomes hard to read, test, and maintain. One of the best solutions to this problem is using the Service Pattern — a pattern that helps separate your business logic from your controllers.

In this blog, we'll dive deep into how to implement the Service Pattern in Laravel. We’ll walk through the folder structure, build a real-world example with custom Form Requests, and show how the service layer improves code clarity and maintainability — all without using a Repository.

🧠 What is the Service Pattern?

The Service Pattern is a design principle where you offload complex or reusable business logic into a Service class. This keeps your controllers clean and your application logic in one place, making it easier to test and reuse.

✨ Why use the Service Pattern?

• Separation of concerns: Controllers handle requests, services handle logic.

• Testability: You can write unit tests for service methods easily.

• Reusability: Use the same service in multiple places.

• Cleaner Controllers: Easier to read, maintain, and debug

📁 Folder Structure

To organize your service logic effectively, here’s a commonly used folder structure:

app/
├── Http/
│   ├── Controllers/
│   │   └── AuthController.php
│   ├── Requests/
│   │   └── RegisterUserRequest.php
│
├── Services/
│   └── Auth/
│       └── RegisterService.php
│
├── Models/
│   └── User.php

This structure:

• Places each concern in its own folder

• Makes it easier to scale and add features

• Keeps logic modular and traceable

💡 Use Case: User Registration

Let’s say we’re building a simple user registration feature. We want:

• Validation using a custom Form Request

• Business logic inside a Service

• A clean, readable controller

🧾 Step 1: Create a Custom Form Request

We’ll use Laravel’s FormRequest to handle validation cleanly.

File: app/Http/Requests/RegisterUserRequest.php

namespace App\Http\Requests;

use Illuminate\Foundation\Http\FormRequest;

class RegisterUserRequest extends FormRequest
{
    public function authorize(): bool
    {
        // Can add authorization logic here
        return true;
    }

    public function rules(): array
    {
        return [
            'first_name' => 'required|string|max:255',
            'last_name'  => 'required|string|max:255',
            'email'      => 'required|email|unique:users,email',
            'password'   => 'required|string|min:8|confirmed',
        ];
    }
}

Here:

• authorize() lets us control access (e.g. based on roles).

• rules() defines the validation logic.

When you use this in a controller, Laravel auto-validates the request.

⚙️ Step 2: Create the Service Class

This class will handle all the registration logic.

File: app/Services/Auth/RegisterService.php

namespace App\Services\Auth;

use App\Models\User;
use Illuminate\Support\Facades\Hash;

class RegisterService
{
    public function register(array $data): User
    {
        return User::create([
            'first_name' => $data['first_name'],
            'last_name'  => $data['last_name'],
            'email'      => $data['email'],
            'password'   => Hash::make($data['password']),
        ]);
    }
}

Now all business logic — such as password hashing, user creation — lives here. It’s reusable and easy to test.

🎮 Step 3: Use Service in Controller

Now, let’s call our service in the controller. This keeps the controller clean and focused on handling HTTP.

File: app/Http/Controllers/AuthController.php

namespace App\Http\Controllers;

use App\Http\Requests\RegisterUserRequest;
use App\Services\Auth\RegisterService;
use Illuminate\Http\JsonResponse;

class AuthController extends Controller
{
    protected RegisterService $registerService;

    public function __construct(RegisterService $registerService)
    {
        $this->registerService = $registerService;
    }

    public function register(RegisterUserRequest $request): JsonResponse
    {
        $user = $this->registerService->register($request->validated());

        return response()->json([
            'message' => 'User registered successfully.',
            'user'    => $user,
        ], 201);
    }
}

Let’s break this down:

• The constructor injects the RegisterService using Laravel’s service container.

• The register() method receives validated data from RegisterUserRequest.

• It delegates logic to the service, and simply returns a response.

✅ Now your controller is lean, readable, and testable.

🧪 How to Test Your Service

Because your service is decoupled from the controller, you can unit test it easily:

public function test_user_can_be_registered()
{
    $service = new RegisterService();

    $user = $service->register([
        'first_name' => 'John',
        'last_name'  => 'Doe',
        'email'      => '[email protected]',
        'password'   => 'password123',
    ]);

    $this->assertDatabaseHas('users', ['email' => '[email protected]']);
}

🧼 Final Thoughts

The Service Pattern is a proven architectural approach in Laravel for building scalable, maintainable apps. It shines when:

• You need to keep controllers slim

• You want reusable business logic

• You want to write better tests

🛠 Summary