Laravel Filament 5: Building Admin Panels, Resources & Multi-Panel Applications

Introduction

Building a custom administration area in Laravel can require a lot of repetitive work: authentication screens, navigation, forms, tables, CRUD operations, actions, dashboards, and access control all need to be designed and maintained.

Laravel Filament provides a Laravel-native toolkit for building these interfaces quickly while keeping the application code flexible and customizable. Instead of building every admin screen from scratch, you can define resources, forms, tables, pages, widgets, and panel configuration in PHP.

In this practical guide, we will build a small Laravel application with an Admin panel, a Customer resource, a custom table action, and a second Employee panel. The examples focus on the concepts that matter when building real Laravel applications with Filament 5.

Version note: This guide targets the Filament 5.x series. Filament APIs and generated code can differ between major versions, so always check the documentation for the version installed in your project.

What Is Laravel Filament?

Filament is a Laravel framework for building admin panels and application interfaces. It provides components for forms, tables, notifications, actions, widgets, resources, authentication, and panel configuration.

A key concept is the Panel. A panel represents an application interface with its own URL, authentication behavior, navigation, resources, pages, widgets, branding, middleware, and other configuration.

This makes Filament useful for applications that need more than one authenticated interface, such as:

• Admin dashboard

• Employee or staff dashboard

• Customer portal

• Internal operations panel

• SaaS application interfaces

For current Filament 5 projects, panel configuration is handled through PanelProvider classes rather than relying on the older global configuration approach used in earlier examples.

Why Use Filament?

Filament is especially useful when a Laravel application needs a data-heavy interface and you want to avoid rebuilding common admin UI patterns from scratch.

Rapid CRUD Development

Resources provide a structured way to manage Eloquent models through forms and tables.

Forms and Tables

Filament provides reusable components for inputs, selects, validation, table columns, searching, sorting, filtering, actions, and more.

Panels

Different panels can have different URLs, navigation, branding, resources, and access rules.

Authentication

Filament provides authentication pages and integrates with Laravel's authentication system, while panel access can be controlled at the application level.

Customization

Panels, resources, pages, widgets, navigation, themes, and actions can be customized to match the application's requirements.

Laravel-Native Development

Filament works directly with Laravel models, policies, authentication, migrations, queues, notifications, and other framework features.

Prerequisites

Before starting, make sure your environment satisfies the requirements of the Laravel and Filament versions you plan to install.

For a current Filament 5 project, verify the supported PHP and Laravel versions in the official Filament documentation before installation. Compatibility can change across Filament releases.

You should also have:

• PHP and Composer installed

• A working Laravel application

• A configured database

• Basic knowledge of Laravel models, migrations, authentication, and Eloquent

• Node.js and npm if you plan to build custom frontend assets or themes

Step 1: Install Filament

For a fresh or existing Laravel application, install Filament through Composer and then run its installation command.

composer require filament/filament:"^5.0"
php artisan filament:install --panels

The panel installation process creates the panel provider structure used by the application.

After installation, run your normal Laravel database setup if migrations are pending:

php artisan migrate

Start the application:

php artisan serve

The generated Admin panel is typically available at:

<http://localhost:8000/admin>

The exact URL can be changed through the panel provider.

Step 2: Create an Admin User

Once the panel is installed, create a user that can authenticate with the panel:

php artisan make:filament-user

The command prompts you for the user's name, email address, and password.

After creating the account, open the Admin panel and sign in with the new credentials.

Step 3: Understand the Panel Provider

The panel provider is the central place where a Filament panel is configured.

A typical provider is located under:

app/Providers/Filament/AdminPanelProvider.php

A simplified example looks like this:

<?php
namespace App\Providers\Filament;
use Filament\Panel;
use Filament\PanelProvider;
class AdminPanelProvider extends PanelProvider
{
    public function panel(Panel $panel): Panel
    {
        return $panel
            ->default()
            ->id('admin')
            ->path('admin');
    }
}

The important idea is that panel configuration lives with the panel provider. As the application grows, you can add authentication, middleware, branding, navigation, resources, pages, widgets, plugins, and other panel-specific behavior here.

Step 4: Create a Customer Model

We will use a simple Customer model to demonstrate a CRUD resource.

Create the model and migration:

php artisan make:model Customer -m

Define the table:

Schema::create('customers', function (Blueprint $table) {
    $table->id();
    $table->string('name');
    $table->string('email')->unique();
    $table->string('phone')->nullable();
    $table->timestamps();
});

Run the migration:

php artisan migrate

Step 5: Generate a Filament Resource

A Filament resource provides the interface used to manage an Eloquent model.

Generate the Customer resource:

php artisan make:filament-resource Customer

Depending on the generated resource structure and options, Filament creates the resource and its related pages/classes.

The resource becomes the place where you define how customers are created, edited, listed, viewed, filtered, and otherwise managed inside the panel.

Step 6: Build the Customer Form

A form defines the fields users interact with when creating or editing a customer.

For example:

use Filament\Forms\Components\TextInput;
use Filament\Schemas\Schema;
public static function form(Schema $schema): Schema
{
    return $schema
        ->components([
            TextInput::make('name')
                ->required()
                ->maxLength(255),
TextInput::make('email')
                ->email()
                ->required()
                ->unique(ignoreRecord: true),
TextInput::make('phone')
                ->tel()
                ->maxLength(20),
        ]);
}

The exact generated method signature can vary with the Filament major version, so use the generated resource as the starting point and adapt the schema using the version-specific documentation.

Step 7: Build the Customer Table

The table defines how customer records appear in the resource list.

For example:

use Filament\Tables\Columns\TextColumn;
use Filament\Tables\Table;
public static function table(Table $table): Table
{
    return $table
        ->columns([
            TextColumn::make('name')
                ->searchable()
                ->sortable(),
TextColumn::make('email')
                ->searchable()
                ->sortable(),
TextColumn::make('phone'),
TextColumn::make('created_at')
                ->dateTime()
                ->sortable(),
        ]);
}

With these definitions, the Customer resource provides a much more complete data-management experience without requiring separate controllers and Blade views for every CRUD screen.

Step 8: Add a Custom Record Action

Filament resources can expose actions that perform business operations on individual records.

For example, a customer table could provide a Send Welcome Email action.

A simplified concept looks like:

use Filament\Actions\Action;
Action::make('sendWelcomeEmail')
    ->label('Send Welcome Email')
    ->requiresConfirmation()
    ->action(function (Customer $record) {
        $record->sendWelcomeEmail();
    });

The exact location of record actions depends on the Filament 5 table/action API used by the generated resource. The important pattern is that the action stays close to the resource interface while the underlying business logic remains in an appropriate application service or model method.

Step 9: Create a Second Panel

One of Filament's useful capabilities is the ability to create multiple panels in the same Laravel application.

For example, we can create an Employee panel:

php artisan make:filament-panel employee

This generates another panel provider, such as:

app/Providers/Filament/EmployeePanelProvider.php

A simplified provider can define a different ID and URL:

<?php
namespace App\Providers\Filament;
use Filament\Panel;
use Filament\PanelProvider;
class EmployeePanelProvider extends PanelProvider
{
    public function panel(Panel $panel): Panel
    {
        return $panel
            ->id('employee')
            ->path('employee');
    }
}

The application can now have separate interfaces such as:

/admin
/employee

Each panel can then be configured with its own resources, navigation, branding, authentication behavior, middleware, and other requirements.

Step 10: Control Panel Access

Creating multiple panels does not automatically mean every authenticated user should be able to access every panel.

Panel access should be explicitly controlled.

Filament supports panel access through the application's authenticatable user model and the canAccessPanel() method.

For example:

use Filament\Panel;
use Filament\Models\Contracts\FilamentUser;
class User extends Authenticatable implements FilamentUser
{
    public function canAccessPanel(Panel $panel): bool
    {
        return match ($panel->getId()) {
            'admin' => $this->is_admin,
            'employee' => $this->is_employee,
            default => false,
        };
    }
}

The exact authorization rules should match the application's user and role model. For production applications, avoid relying only on hidden navigation items; access should be enforced server-side.

Step 11: Role and Permission Management

For applications with more detailed authorization requirements, you can integrate Filament with Laravel authorization policies or a package such as Spatie Laravel Permission.

A typical permission model might distinguish between:

• Super Admin

• Admin

• Manager

• Employee

• Support Staff

For example, a manager might be allowed to view and edit customers while an employee can only view them.

The important principle is to keep authorization rules explicit and enforce them on the server. Filament's resources and panels should reflect the application's authorization model rather than becoming the authorization model themselves.

Step 12: Customize Branding and Navigation

Panel providers can be customized for the application's branding and user experience.

Typical customization areas include:

• Brand name

• Logo

• Favicon

• Primary colors

• Navigation groups

• Navigation labels

• Panel path

• Authentication pages

• Middleware

• User menu items

• Custom themes

For example:

return $panel
    ->id('admin')
    ->path('admin')
    ->brandName('My Company Admin');

For multiple panels, each provider can have its own branding and navigation strategy.

Admin Panel vs Employee Panel

A multi-panel architecture becomes useful when different groups need different interfaces.

The exact structure should depend on the application. A second panel is not automatically required just because the application has different roles; sometimes one panel with role-based navigation and authorization is simpler.

When Should You Use Multiple Panels?

Multiple panels are useful when users need genuinely different application experiences.

Consider multiple panels when:

• Admins and employees need different navigation structures.

• Different user groups require different authentication or access rules.

• Each audience needs a substantially different dashboard.

• Resources should be scoped to different panels.

• Different branding or URLs are useful.

A single panel may be preferable when the differences are small and can be handled through policies, navigation visibility, and role-based permissions.

Common Mistakes to Avoid

Treating Filament as Only a CRUD Generator

Filament can provide much more than basic CRUD. Use resources, pages, widgets, actions, notifications, and panel configuration according to the application's needs.

Hiding Navigation Instead of Authorizing Access

Removing a navigation item does not replace server-side authorization. Always enforce access through the appropriate authorization layer.

Mixing Major-Version Examples

Filament's APIs can change between major versions. Avoid copying a Filament 3 or 4 example into a Filament 5 application without checking the current documentation.

Putting Business Logic Everywhere

Resource classes should define the admin interface, but complex business rules are usually better kept in domain services, actions, jobs, or model methods where appropriate.

Creating Multiple Panels Without a Real UX Need

More panels mean more configuration and more interfaces to maintain. Use them when the application's user experience genuinely benefits from separation.

Result

After following the guide, you have the foundation for a Laravel application with:

• A Filament Admin panel

• Admin authentication

• A Customer resource

• Customer forms and tables

• Searchable and sortable data

• Custom record actions

• A separate Employee panel

• Panel-specific access control

• A foundation for roles and permissions

• Panel-specific branding and navigation

Key Learnings

• Filament can significantly reduce the repetitive work involved in Laravel admin development.

• Resources provide a structured way to build model-driven forms and tables.

• Panel providers are central to configuring individual Filament panels.

• Multiple panels are useful when different audiences need genuinely different application experiences.

• Authentication and authorization should be designed separately from navigation visibility.

• Filament major versions can introduce API changes, so version-specific documentation matters.

Final Thoughts

Laravel Filament is a strong choice when a Laravel application needs a polished, data-driven administrative interface without building every component from scratch.

The real advantage is not simply generating CRUD screens. It is the ability to compose panels, resources, forms, tables, actions, widgets, authentication, authorization, and custom application behavior around Laravel's existing architecture.

For a small internal tool, Filament can dramatically shorten development time. For a larger application, its panel architecture can provide a structured foundation while still allowing the interface to evolve with the product.

Official References

• Filament

• Filament Documentation

• Filament GitHub

• Laravel Documentation

• Spatie Laravel Permission