Filament PHP: Building Admin Panels and How to Host Them

Key Takeaways

• Filament liberates you from writing front-end code for admin interfaces
• It quickly creates CRUD screens, SaaS dashboards, CMS, and internal tools
• Get rapid CRUD scaffolding, a rich form builder with over 30 field types, filterable tables, and built-in role-based access.
• It has high customizability, an active plugin ecosystem, and a multi-panel architecture at zero licensing cost

Teams developing a Laravel app sometimes hit a common roadblock. The core product came together fast up to this point, yet a need to manage the data behind it becomes apparent. So, you start wiring up CRUD screens. As time drags on, you realize that what actually matters, the product, is on the backburner.

Filament PHP exists to maximize business efficiency. It’s an open-source component library for Laravel that gives you admin panels, forms, and data tables without building any of it yourself. No custom front-end code, no JavaScript. It runs on Livewire, Alpine.js, and Tailwind CSS, so the UI is reactive by default.

This guide covers what Filament is, how to get it installed, how to build your first working panel, and how to put it on a real server using Cloudways.

What is Filament PHP?

Filament is essentially a UI framework that adds no costs to your projects, is open-source, and works via Laravel and Livewire. You get a library of ready-made, fully interactive components (panels, forms, tables, notifications, widgets) that you assemble into admin dashboards and back-office tools without writing front-end code from scratch.

Four things make it work under the hood: Laravel handles the application layer, Livewire takes care of server-side reactivity so your UI updates without a full page reload, Alpine.js covers lightweight browser interactions like dropdowns and modals, and Tailwind CSS handles the styling.

It first shipped in January 2022 and has grown quickly since. Version 3 is the current stable release. It introduced multi-panel support and a much bigger component set. V4 is in active development and has been generating a lot of chatter, judging by the search interest in Filament PHP v4 release date, that’s been building for a year.

What is Filament PHP used for?

Filament is mostly used to build the admin side of Laravel apps: the screens your team (or your clients) use to manage data, not the public-facing front end. Here are a few common real-world use cases:

Use Case	Example	Key Filament components
Admin dashboard	SaaS back-office for managing users and subscriptions	Panels, Stats Widgets, Charts
Content management	Blog CMS with post, tag, and author management	Resources, Rich Text Editor, Media Library
E-commerce back-office	Order management, product catalog, inventory tracking	Resources, Tables, Filters, Actions
CRM	Customer records, pipeline stages, activity logs	Resources, Infolists, Timeline Widget
Internal tools	Employee directory, support ticket dashboard	Custom pages, Tables, Notifications
Multi-tenant SaaS	Separate admin panels per tenant with their own auth guard	Multi-panel setup, Policies

Why use Filament PHP? Key features and benefits

Devs and agencies opt for Filament PHP as it helps them create admin interfaces much faster, without compromising quality or customizability. This is what makes it so special.

Rapid CRUD generation

With a single Artisan command, Filament scaffolds a complete resource with a form, a filterable table, and full create/read/update/delete actions. What would take days to build manually can be up and running in minutes.

A rich form builder with 30+ field types

Filament has a complete form builder with text inputs, rich text editors, select dropdowns, date pickers, file upload components with image previews, toggle switches, color pickers, key-value inputs, repeater fields and more. Every field has built-in validation integration with Laravel’s validator.

Filterable, sortable, searchable tables

The table builder lets you define columns, filters, sort controls, and bulk actions in pure PHP. It handles pagination, column toggling, and live search out of the box with no front-end configuration required.

Role-based access and authorization

Filament has built-in integration with Laravel’s policy system, so you can use the same auth patterns you already use in your app to control who can view, create, update or delete any resource.

Multi-panel support

Filament v3 introduced the ability to define multiple independent panels within a single Laravel app. For example, one panel for admins, another for customers, and another for support agents, each with its own routes, auth guards, and branding.

A growing plugin ecosystem

The Filament plugin directory includes dozens of community-built extensions: calendar widgets, Kanban boards, tree navigation, Excel exports, audit logs, and more. Most are free and installable via Composer.

Dark mode, responsive design, and custom theming

All Filament panels are mobile-responsive and include built-in dark mode support. You can customize the color scheme, logo, navigation structure, and font by publishing the Tailwind configuration and adjusting a bunch of variables.

Filament PHP vs. other Laravel admin panels

Filament isn’t the only option for building admin panels in Laravel. Here’s how it compares to the most popular alternatives:

	Filament PHP	Laravel Nova	Backpack for Laravel	Orchid
License	Free (MIT)	Paid ($99–$199/site)	Freemium	Free (MIT)
Built on Livewire	Yes	No (Vue.js)	No (Blade/Vue)	No (Blade)
Multi-panel support	Yes (v3+)	No	No	No
Plugin ecosystem	Large & growing	Moderate	Moderate	Small
Learning curve	Low–moderate	Low	Moderate	Moderate
Customizability	High	High	High	Moderate
Active development	Very active	Active	Active	Active

Sources: Filament PHP, Laravel Nova,  Backpack for Laravel, Orchid

For most Laravel developers (especially those building SaaS products, agency client sites, or internal tools) Filament hits the sweet spot of speed, quality, and zero licensing cost. Laravel Nova is the main paid alternative worth considering if your team is already deeply invested in a Vue.js front-end workflow.

How to install Filament PHP

This section walks you through installing Filament on a fresh (or existing) Laravel application. Screenshots will be added here from my own setup to illustrate each step.

Number of Steps: 6 steps
Time Required: A few minutes (The entire process of building and hosting can be done in under an hour)
Technical Complexity: Low to Moderate (Requires familiarity with the terminal and Laravel basics)
Core Tools Used: Composer, Laravel Artisan commands
Key Outcome: A fully functional, dark-mode capable admin interface ready for customization

Prerequisites

Before you begin, make sure your development environment meets the following requirements:

• PHP 8.1 or higher — Filament v3 requires PHP 8.1+ (PHP 8.2+ is recommended; check the official docs if you’re targeting Filament v4, which may raise this requirement)
• Laravel 10 or higher — Filament v3 supports Laravel 10 and 11
• Composer — for package installation
• Node.js and npm — only needed if you plan to customise the Tailwind theme; not required for a standard install
• A database — MySQL, PostgreSQL, or SQLite all work fine for local development

If your current hosting environment doesn’t meet these requirements, Cloudways PHP hosting gives you clean, fully managed servers with the latest PHP versions available at the click of a button.

Step 1: Create a new Laravel application

If you’re starting from scratch, create a new Laravel project:

composer create-project laravel/laravel my-admin-app
cd my-admin-app

If you have an existing application, skip this step and continue from your project root. Make sure your .env file is configured and your database connection works before proceeding.

Step 2: Require Filament via Composer

Install the Filament package:

composer require filament/filament:"^3.0" -W

The -W flag allows Composer to update dependencies as needed. Filament pulls in Livewire, Alpine.js, and its own component packages automatically.

Step 3: Install Filament and create your first panel

Run the Filament install command:

php artisan filament:install --panels

This command does a couple of things at once: publishing the service provider from Filament, setting up the default admin panel (registered at /admin), and publishing the Filament assets to your project. You’ll be asked to confirm the panel ID. Pressing Enter accepts the default (admin).

Step 4: It’s time to Haul

Filament adds a users table and relies on a standard Laravel database setup. Run your migrations:

php artisan migrate

Step 5: Create an admin user

Create your first user account:

php artisan make:filament-user

Filament will prompt you for a name, email address, and password. This user is automatically granted access to the admin panel.

Step 6: Fire up the dev server, log in

Start Laravel’s built-in development server:

php artisan serve

Then open http://localhost:8000/admin in your browser. Log in with the credentials you just created. You should see Filament’s default dashboard: a clean, dark-mode-capable admin interface ready for customization.

Building your first admin panel with Filament PHP

Now that Filament is installed, let’s build something real. In this walkthrough, you’ll create a Posts resource — a full CRUD interface for managing blog posts. Screenshots will be added here from the author’s own setup.

Step 1: Create the Post model and migration

Start with a standard Laravel model:

php artisan make:model Post -m

Open the generated migration file in database/migrations/ and define the posts table:

Schema::create('posts', function (Blueprint $table) {
    $table->id();
    $table->string('title');
    $table->string('slug')->unique();
    $table->longText('body');
    $table->enum('status', ['draft', 'published'])->default('draft');
    $table->timestamp('published_at')->nullable();
    $table->timestamps();
});

Run the migration:

php artisan migrate

Step 2: Generate a Filament Resource

Filament can scaffold a complete resource (form, table, and pages) from your model:

php artisan make:filament-resource Post --generate

The –generate flag tells Filament to inspect your model’s database columns and auto-populate the form and table definitions. This creates the following files:

• app/Filament/Resources/PostResource.php — the main resource class
• app/Filament/Resources/PostResource/Pages/ListPosts.php
• app/Filament/Resources/PostResource/Pages/CreatePost.php
• app/Filament/Resources/PostResource/Pages/EditPost.php

Step 3: Define the form

Open PostResource.php and locate the form() method. Here’s a clean version that demonstrates the most useful field types:

public static function form(Form $form): Form
{
    return $form->schema([
        Forms\Components\TextInput::make('title')
            ->required()
            ->maxLength(255)
            ->live(onBlur: true)
            ->afterStateUpdated(fn ($state, callable $set) =>
                $set('slug', Str::slug($state))
            ),
        Forms\Components\TextInput::make('slug')
            ->required()
            ->unique(Post::class, 'slug', ignoreRecord: true),
        Forms\Components\RichEditor::make('body')
            ->required()
            ->columnSpanFull(),
        Forms\Components\Select::make('status')
            ->options(['draft' => 'Draft', 'published' => 'Published'])
            ->required(),
        Forms\Components\DateTimePicker::make('published_at'),
    ]);
}

Step 4: Define the table

Find the table() method and configure the columns and filters:

public static function table(Table $table): Table
{
    return $table
        ->columns([
            Tables\Columns\TextColumn::make('title')
                ->searchable()
                ->sortable(),
            Tables\Columns\BadgeColumn::make('status')
                ->colors(['warning' => 'draft', 'success' => 'published']),
            Tables\Columns\TextColumn::make('published_at')
                ->dateTime()
                ->sortable(),
            Tables\Columns\TextColumn::make('created_at')
                ->dateTime()
                ->sortable()
                ->toggleable(isToggledHiddenByDefault: true),
        ])
        ->filters([
            Tables\Filters\SelectFilter::make('status')
                ->options(['draft' => 'Draft', 'published' => 'Published']),
        ])
        ->defaultSort('created_at', 'desc');
}

Step 5: Adding a stats widget to the dashboard

A bare dashboard isn’t particularly useful. Let’s add a stats overview widget showing how many posts are in each status:

php artisan make:filament-widget PostStatsOverview --stats-overview

Open the generated file and define your stats:

protected function getStats(): array
{
    return [
        Stat::make('Total Posts', Post::count()),
        Stat::make('Published', Post::where('status', 'published')->count())
            ->color('success'),
        Stat::make('Drafts', Post::where('status', 'draft')->count())
            ->color('warning'),
    ];
}

Step 6: Customising navigation and branding

Open app/Providers/Filament/AdminPanelProvider.php and adjust the panel configuration:

->brandName('My App Admin')
->brandLogo(asset('images/logo.svg'))
->favicon(asset('images/favicon.ico'))
->colors(['primary' => Color::Blue])
->darkMode(false) // disable dark mode toggle if preferred

Filament also lets you set custom navigation groups and icons on each resource using the $navigationGroup and $navigationIcon properties in your resource class. You can find available icons at Heroicons (https://heroicons.com), which Filament uses by default.

Filament PHP admin panel features worth knowing

Beyond the basics covered above, Filament has several features that make it genuinely powerful for production projects.

Infolists for read-only record views

Forms are for editing. Tables are for listing. But sometimes you just need to show someone a record without giving them the ability to change anything. That’s what Infolists are for. A separate layout system built specifically for read-only detail views. Useful for CRM-style tools where your team needs to pull up a customer record without accidentally touching it.

Custom pages

Not everything fits the CRUD mold. Filament lets you build completely custom pages (reports, onboarding flows, internal dashboards) that live inside the panel’s navigation and authentication like any other resource, but contain whatever Livewire logic you need. You’re not locked into the resource pattern.

Notifications

You can fire in-browser flash notifications from anywhere in the app or persist them to the database if you need a notification inbox. It hooks into Laravel’s existing notification system, and because it’s built on Livewire, everything updates without a page reload.

Actions, bulk actions, and table action groups

Every table row can have its own actions: edit, delete, preview, export, whatever you need. Bulk actions work the same way across multiple selected rows. The pattern Filament uses is modal forms rather than new pages, which keeps the workflow fast. A quick status change doesn’t need to send the user anywhere.

Multi-panel architecture

This is the one that makes Filament genuinely useful for SaaS products. A single Laravel app can run multiple completely independent Filament panels each with its own route prefix, auth guard, middleware, navigation, branding, and set of resources. So your admin panel at /admin and your customer portal at /portal share the same models and business logic, but look and behave like entirely separate products. No need for a second Laravel app.

How to host a Filament PHP app on Cloudways

Once your Filament application is ready for the world, you need a hosting environment that’s fast, secure, and easy to manage. Cloudways is a managed cloud hosting platform built specifically for PHP and Laravel applications. It handles server configuration, cyber security, and tech tweaks so you can focus on your code.

With Cloudways, you can deploy on your choice of cloud infrastructure provider (DigitalOcean, AWS, Google Cloud, Vultr, or Linode) without needing to manage the servers yourself. It’s a strong fit for Filament: the platform supports PHP 8.1+, includes built-in Redis (which Filament uses for its queue-based notification system), and provides one-click SSL and staging environments.

Step 1: Sign up and launch a server

Go to cloudways.com and sign up for an account (there’s a 3-day free trial, no credit card required). Once you’re in the platform, click Launch to create a new server.

In the server configuration screen, select:

• Application: PHP Stack (for a clean PHP environment)
• Cloud provider: your preference — DigitalOcean is the most popular starting point
• Server size: 1GB RAM is sufficient for development; 2GB+ is recommended for production
• Server location: choose the region closest to your users

Step 2: Configure your PHP application

After your server launches (takes 5–10 minutes), navigate to your server in the Cloudways dashboard and open the Applications tab. Click Add Application, select PHP Stack, and give your application a name.

Under Application Settings, note your application’s public path — it should point to your Laravel project’s public/ directory. You can set this after deployment.

Step 3: Set the PHP version

Filament PHP requires PHP 8.1+. In your application’s settings, navigate to Application Settings → PHP and select PHP 8.2 or 8.3 from the dropdown. Hit Save Changes.

📝 Cloudways lets you switch PHP versions at any time without downtime — handy if Filament v4 ships with higher requirements.

Step 4: Deploy your application via Git

The cleanest way to deploy a Laravel/Filament app on Cloudways is via Git. In the Deployment via Git section of your application settings:

1. Paste your repository URL (GitHub, GitLab, or BitBucket).
2. Set the branch to deploy (main or production).
3. Set the deployment path to your app’s public folder.
4. Click Pull to deploy.

Alternatively, you can upload your application files via SFTP or use the Cloudways application migration add-on if you’re moving an existing site. Find your SFTP credentials under Access Details in your server panel.

Step 5: Configure your environment variables

SSH into your server (credentials are under Access Details → Master Credentials) or use Cloudways’ browser-based terminal. Navigate to your application’s root directory and configure your .env file:

APP_NAME='My Admin App'
APP_ENV=production
APP_KEY=  # generate with: php artisan key:generate
APP_DEBUG=false
APP_URL=https://yourdomain.com
DB_CONNECTION=mysql
DB_HOST=127.0.0.1
DB_PORT=3306
DB_DATABASE=  # your Cloudways DB name
DB_USERNAME=  # your Cloudways DB user
DB_PASSWORD=  # your Cloudways DB password
CACHE_DRIVER=redis
SESSION_DRIVER=redis
QUEUE_CONNECTION=redis

Your database credentials are available in the Cloudways platform under Application Management → Access Details. Cloudways pre-installs Redis on every server, so the Redis configuration works immediately.

Run your migrations and seed any required data:

php artisan migrate --force
php artisan filament:optimize  # caches Filament's component discovery

Step 6: Point your domain and enable SSL

In the Cloudways dashboard, go to Application Management → Domain Management and add your custom domain. Update your domain registrar’s DNS to point your A record to your Cloudways server IP (shown in the Server Management screen).

Once DNS propagates, go to SSL Certificate in the application settings and click Let’s Encrypt to issue a free SSL certificate in one click. Cloudways handles the renewal automatically, so you never need to think about it again. Learn more about free SSL hosting on Cloudways.

Step 7: Set up the task scheduler

Filament uses Laravel’s task scheduler for certain background operations (such as scheduled notifications). Add the following cron job to your server — in Cloudways, this can be done under Server Management → Cron Job Manager:

* * * * * cd /path-to-your-app && php artisan schedule:run >> /dev/null 2>&1

If you’re using Filament’s database notifications or any queued actions, also start the queue worker. Cloudways supports running it as a Supervisor-managed process for reliability.

📝 Cloudways also offers a one-click staging environment — perfect for testing Filament updates before pushing to production. Find it under Application Management → Staging Management.

What are the limitations of Filament PHP?

TALL Stack Lock-in: Tightly coupled to Tailwind, Alpine.js, Laravel and Livewire. If you and your team like front-end frameworks like Vue, React or Inertia then this is not for you.js

Performance of Complex UIs: Since it uses Livewire (which makes network requests to the server for state changes), very complex or real-time interactive interfaces can feel slower than a true Single Page Application (SPA).

Rigid Customization: Very optimized for the default admin panel layouts. Building highly bespoke, non-standard components is difficult and requires fighting the framework to break out of its predefined UI patterns.

Learning Curve: Developers need to learn not only Laravel, but also Livewire and a whole new, expansive API specific to Filament.

Overkill for Small Projects: If you are doing very simple apps or basic CRUD tasks, the overhead of setting up and configuring Filament might be unnecessary compared to the classic Laravel controllers and blade templates.

Conclusion

Filament PHP is one of the most exciting tools out there for Laravel devs right now. It totally removes the friction from building admin interfaces. You’ve got a polished, reactive, and customizable admin panel using surprisingly little code, allowing you to focus on what makes your app a money printer.

Pair it with Cloudways managed Laravel hosting and you have a complete, production-ready stack: Filament handles the admin UI, Cloudways handles the server infrastructure, and you get to spend your time building features instead of wrestling with configuration.

Whether you’re an agency building client portals, a startup shipping a SaaS back-office, or a developer creating an internal tool, Filament PHP on Cloudways is a setup worth trying. Start your free Cloudways trial and have your first Filament-powered application live in under an hour.

Stop Configuring, Start Building

Experience the fastest way to host, scale, and manage your Laravel applications.

Start Your Free Trial