Building Admin Dashboards with Filament: A Complete Guide for Laravel Developers

Admin panels used to drain weeks from my project timelines. Forms, validation, tables, filters, all that repetitive CRUD code ate up development time I didn't have. Then I discovered Filament.

When I built an admin dashboard for a client's edtech platform managing 500+ schools, Filament saved me roughly 40 hours. What normally takes weeks turned into days. The difference? Filament handles the boring stuff so I can focus on features that actually matter.

This guide covers Filament v4 and v5. The code is identical between versions. Filament v5 (released January 16, 2026) exists purely for Livewire v4 compatibility. There are no API changes from v4 to v5, so everything in this post works on both. If you're upgrading from v3, check the official upgrade guide because the API changed significantly from v3 to v4.

You'll learn how to install Filament, create resources with the separate schema structure, handle relationships properly, customize forms and tables, and avoid mistakes that'll cost you debugging hours. Plus, I'm sharing production techniques from apps handling real users.

What Makes Filament v4/v5 Different From v3

If you're coming from Filament v3, the jump is significant.

The biggest change? Separate schema files. Instead of cramming everything into your resource class, Filament generates dedicated files for forms (Schemas/CustomerForm.php) and tables (Tables/CustomersTable.php). Your resources stay clean. Your code stays maintainable.

The actions system got unified too. Everything lives in Filament\Actions now, no more hunting through separate namespaces for table actions vs form actions. One namespace. One consistent API.

Performance improved dramatically. The new live() method (replacing reactive()) is smarter about when to trigger updates. Client-side JavaScript helpers like hiddenJs() and visibleJs() eliminate unnecessary server roundtrips for simple show/hide logic.

And Filament switched from TinyMCE to Tiptap for rich text editing. Lighter. Faster. Better. The v4.5 release even added native mention support in the Rich Editor, so you can build Slack-like @mention features without custom code.

Here's why this matters for your projects: Filament is built on TALL stack (Tailwind, Alpine.js, Laravel, Livewire). You're not learning proprietary syntax. When you customize something, you're writing regular Livewire components. When you need styling, you're using Tailwind classes you already know.

Plus, it's free. No licensing fees. No per-seat costs. You can manage hundreds of admin users without spending a dollar on the panel itself.

Installing Filament

You need Laravel 11 or 12 with PHP 8.2+. For new projects on Laravel 12, I'd go straight with Filament v5 (which requires Livewire v4). For existing projects on Livewire v3, stick with Filament v4.

Install via Composer:

# For Filament v5 (Livewire v4)
composer require filament/filament:"^5.0"

# For Filament v4 (Livewire v3)
composer require filament/filament:"^4.0"

Run the installation:

php artisan filament:install --panels

This command creates your admin panel in app/Filament, sets up your panel provider, publishes assets, and configures everything. One command does it all.

Create an admin user:

php artisan make:filament-user

Enter your email and password. Done.

Visit /admin. Log in. You've got a working panel.

Two minutes from zero to functional.

Creating Your First Resource

Resources connect your Eloquent models to the admin panel. They're like controllers but way more powerful.

Generate a User resource:

php artisan make:filament-resource User --generate

The --generate flag inspects your User model and automatically creates form fields and table columns based on your database schema. It recognizes relationships and suggests appropriate field types.

This creates several files in app/Filament/Resources/Users/:

app/Filament/Resources/Users/
├── UserResource.php
├── Pages/
│   ├── CreateUser.php
│   ├── EditUser.php
│   └── ListUsers.php
├── Schemas/
│   └── UserForm.php
└── Tables/
    └── UsersTable.php

Forms live in Schemas/. Tables live in Tables/. Way cleaner than v3's massive resource classes.

Here's the generated UserResource.php:

<?php

namespace App\Filament\Resources\Users;

use App\Filament\Resources\Users\Pages\CreateUser;
use App\Filament\Resources\Users\Pages\EditUser;
use App\Filament\Resources\Users\Pages\ListUsers;
use App\Filament\Resources\Users\Schemas\UserForm;
use App\Filament\Resources\Users\Tables\UsersTable;
use App\Models\User;
use BackedEnum;
use Filament\Resources\Resource;
use Filament\Schemas\Schema;
use Filament\Support\Icons\Heroicon;
use Filament\Tables\Table;

class UserResource extends Resource
{
    protected static ?string $model = User::class;

    protected static string|BackedEnum|null $navigationIcon = Heroicon::OutlinedRectangleStack;

    public static function form(Schema $schema): Schema
    {
        return UserForm::configure($schema);
    }

    public static function table(Table $table): Table
    {
        return UsersTable::configure($table);
    }

    public static function getRelations(): array
    {
        return [
            //
        ];
    }

    public static function getPages(): array
    {
        return [
            'index' => ListUsers::route('/'),
            'create' => CreateUser::route('/create'),
            'edit' => EditUser::route('/{record}/edit'),
        ];
    }
}

Notice how clean it is? The form and table configuration live elsewhere.

Check UserForm.php:

<?php

namespace App\Filament\Resources\Users\Schemas;

use Filament\Forms\Components\DateTimePicker;
use Filament\Forms\Components\TextInput;
use Filament\Schemas\Schema;

class UserForm
{
    public static function configure(Schema $schema): Schema
    {
        return $schema
            ->components([
                TextInput::make('name')
                    ->required()
                    ->maxLength(255),
                    
                TextInput::make('email')
                    ->email()
                    ->required()
                    ->maxLength(255),
                    
                DateTimePicker::make('email_verified_at'),
                
                TextInput::make('password')
                    ->password()
                    ->required()
                    ->maxLength(255),
            ]);
    }
}

And UsersTable.php:

<?php

namespace App\Filament\Resources\Users\Tables;

use Filament\Actions\BulkActionGroup;
use Filament\Actions\DeleteBulkAction;
use Filament\Actions\EditAction;
use Filament\Tables\Columns\TextColumn;
use Filament\Tables\Table;

class UsersTable
{
    public static function configure(Table $table): Table
    {
        return $table
            ->columns([
                TextColumn::make('name')->searchable(),
                TextColumn::make('email')->searchable(),
                TextColumn::make('email_verified_at')
                    ->dateTime()
                    ->sortable(),
                TextColumn::make('created_at')
                    ->dateTime()
                    ->sortable()
                    ->toggleable(isToggledHiddenByDefault: true),
            ])
            ->filters([])
            ->recordActions([
                EditAction::make(),
            ])
            ->toolbarActions([
                BulkActionGroup::make([
                    DeleteBulkAction::make(),
                ]),
            ]);
    }
}

Refresh /admin. You've got full CRUD for users.

But this is just the start.

Customizing Forms

Forms use the Schema object with components(). Here's a real-world example for a SaaS user management form:

use Filament\Forms\Components\Section;
use Filament\Forms\Components\Select;
use Filament\Forms\Components\TextInput;
use Filament\Forms\Components\Toggle;
use Filament\Schemas\Schema;

public static function configure(Schema $schema): Schema
{
    return $schema
        ->components([
            Section::make('User Information')
                ->schema([
                    TextInput::make('name')
                        ->required()
                        ->maxLength(255)
                        ->columnSpan(1),
                        
                    TextInput::make('email')
                        ->email()
                        ->required()
                        ->unique(ignoreRecord: true)
                        ->columnSpan(1),
                ])
                ->columns(2),
            
            Section::make('Subscription Settings')
                ->schema([
                    Toggle::make('is_active')
                        ->label('Active Account')
                        ->default(true),
                        
                    Select::make('plan')
                        ->options([
                            'free' => 'Free',
                            'pro' => 'Pro',
                            'enterprise' => 'Enterprise',
                        ])
                        ->required()
                        ->live()
                        ->afterStateUpdated(function ($state, $set) {
                            if ($state === 'free') {
                                $set('monthly_limit', 50);
                            } elseif ($state === 'pro') {
                                $set('monthly_limit', 500);
                            } else {
                                $set('monthly_limit', null);
                            }
                        }),
                        
                    TextInput::make('monthly_limit')
                        ->numeric()
                        ->label('Monthly Usage Limit')
                        ->helperText('Leave empty for unlimited'),
                ])
                ->collapsible(),
            
            Section::make('API Configuration')
                ->schema([
                    TextInput::make('api_key')
                        ->label('API Key')
                        ->default(fn () => \Str::random(32))
                        ->disabled()
                        ->helperText('Generated automatically'),
                ])
                ->collapsible()
                ->collapsed(),
        ]);
}

Key things to notice:

• live() replaces v3's reactive() for better performance
• Schema wraps everything with ->components([])
• Sections organize related fields cleanly

The live() method makes forms respond to changes. When someone selects a plan, the usage limit updates automatically. This used to require custom JavaScript. Now it's one method.

Filament also introduced afterStateUpdatedJs() for client-side updates that don't hit the server:

TextInput::make('name')
    ->afterStateUpdatedJs(<<<'JS'
        $set('slug', ($state ?? '').replaceAll(' ', '-').toLowerCase())
    JS)

This eliminates server roundtrips for simple operations. Fast.

Working With Relationships

Relationships are where Filament shines. Let's say you have a Company model with many Employees.

// Company model
public function employees()
{
    return $this->hasMany(Employee::class);
}

In your form schema, use a Repeater:

use Filament\Forms\Components\Repeater;
use Filament\Forms\Components\Select;
use Filament\Forms\Components\TextInput;

Repeater::make('employees')
    ->relationship('employees')
    ->schema([
        TextInput::make('name')
            ->required(),
            
        TextInput::make('email')
            ->email()
            ->required(),
            
        Select::make('department')
            ->options([
                'engineering' => 'Engineering',
                'marketing' => 'Marketing',
                'sales' => 'Sales',
            ]),
    ])
    ->collapsible()
    ->itemLabel(fn (array $state): ?string => $state['name'] ?? null)
    ->addActionLabel('Add Employee')
    ->minItems(1)

This creates an interface where you add multiple employees directly from the company form. The itemLabel() method shows the employee's name when collapsed.

For complex relationships, use Relation Managers:

php artisan make:filament-relation-manager CompanyResource employees name

This generates a full relation manager:

<?php

namespace App\Filament\Resources\CompanyResource\RelationManagers;

use Filament\Forms\Components\Select;
use Filament\Forms\Components\TextInput;
use Filament\Resources\RelationManagers\RelationManager;
use Filament\Schemas\Schema;
use Filament\Tables\Columns\TextColumn;
use Filament\Tables\Table;
use Filament\Actions\CreateAction;
use Filament\Actions\EditAction;
use Filament\Actions\DeleteBulkAction;
use Filament\Actions\BulkActionGroup;

class EmployeesRelationManager extends RelationManager
{
    protected static string $relationship = 'employees';

    public function form(Schema $schema): Schema
    {
        return $schema
            ->components([
                TextInput::make('name')->required(),
                TextInput::make('email')->email()->required(),
                Select::make('department')
                    ->options([
                        'engineering' => 'Engineering',
                        'marketing' => 'Marketing',
                        'sales' => 'Sales',
                    ]),
            ]);
    }

    public function table(Table $table): Table
    {
        return $table
            ->recordTitleAttribute('name')
            ->columns([
                TextColumn::make('name')->searchable(),
                TextColumn::make('email')->searchable(),
                TextColumn::make('department'),
                TextColumn::make('created_at')->dateTime()->sortable(),
            ])
            ->filters([])
            ->headerActions([
                CreateAction::make(),
            ])
            ->recordActions([
                EditAction::make(),
            ])
            ->toolbarActions([
                BulkActionGroup::make([
                    DeleteBulkAction::make(),
                ]),
            ]);
    }
}

Register it in your resource's getRelations() method:

public static function getRelations(): array
{
    return [
        RelationManagers\EmployeesRelationManager::class,
    ];
}

Now when you edit a company, you see an "Employees" tab with a full table. Filter, search, and bulk delete right there. This lets admins manage related records without leaving the parent.

Customizing Tables

Tables use new method names compared to v3. This trips up a lot of developers.

Key syntax:

• recordActions() for row actions (not actions())
• toolbarActions() for bulk actions (not bulkActions())
• Actions live in Filament\Actions namespace

Here's a complete table example for a user management panel:

use Filament\Actions\Action;
use Filament\Actions\BulkActionGroup;
use Filament\Actions\DeleteBulkAction;
use Filament\Actions\EditAction;
use Filament\Support\Enums\FontWeight;
use Filament\Tables\Columns\IconColumn;
use Filament\Tables\Columns\TextColumn;
use Filament\Tables\Filters\SelectFilter;
use Filament\Tables\Filters\TernaryFilter;
use Filament\Tables\Table;
use Illuminate\Database\Eloquent\Collection;

public static function configure(Table $table): Table
{
    return $table
        ->columns([
            TextColumn::make('name')
                ->searchable()
                ->sortable()
                ->description(fn ($record): string => $record->email)
                ->weight(FontWeight::Bold),
            
            TextColumn::make('projects_count')
                ->counts('projects')
                ->label('Projects')
                ->sortable()
                ->badge()
                ->color('success'),
            
            IconColumn::make('is_active')
                ->boolean()
                ->label('Active'),
            
            TextColumn::make('plan')
                ->badge()
                ->color(fn (string $state): string => match ($state) {
                    'free' => 'gray',
                    'pro' => 'success',
                    'enterprise' => 'warning',
                }),
            
            TextColumn::make('created_at')
                ->dateTime()
                ->sortable()
                ->since()
                ->description(fn ($record): string => 
                    $record->created_at->format('M j, Y')
                ),
        ])
        ->filters([
            SelectFilter::make('plan')
                ->options([
                    'free' => 'Free',
                    'pro' => 'Pro',
                    'enterprise' => 'Enterprise',
                ]),
            
            TernaryFilter::make('is_active')
                ->label('Active Status')
                ->placeholder('All users')
                ->trueLabel('Active')
                ->falseLabel('Inactive'),
        ])
        ->recordActions([
            EditAction::make(),
            
            Action::make('resetPassword')
                ->icon('heroicon-o-key')
                ->action(function ($record) {
                    $record->update([
                        'password' => bcrypt('temporary-password'),
                    ]);
                    
                    \Filament\Notifications\Notification::make()
                        ->title('Password reset')
                        ->success()
                        ->send();
                })
                ->requiresConfirmation(),
        ])
        ->toolbarActions([
            BulkActionGroup::make([
                DeleteBulkAction::make(),
                
                Action::make('activateUsers')
                    ->label('Activate Selected')
                    ->icon('heroicon-o-check-circle')
                    ->action(fn (Collection $records) => 
                        $records->each->update(['is_active' => true])
                    )
                    ->deselectRecordsAfterCompletion(),
            ]),
        ])
        ->defaultSort('created_at', 'desc');
}

The description() method adds secondary text below values. I show email addresses under names, keeps tables compact but informative.

Badge columns work great for status fields. The color() method uses match expressions for styling.

Custom actions like resetPassword appear in row dropdowns. One-off operations that don't need full forms. Bulk actions let users select multiple records and act on them at once.

Advanced Form Techniques

These took me months to discover.

Conditional Fields

Show/hide fields based on other values:

use Filament\Forms\Components\DatePicker;
use Filament\Forms\Components\Select;
use Filament\Schemas\Components\Utilities\Get;

Select::make('subscription_type')
    ->options([
        'monthly' => 'Monthly',
        'annual' => 'Annual',
        'lifetime' => 'Lifetime',
    ])
    ->required()
    ->live(),

DatePicker::make('subscription_end_date')
    ->required()
    ->visible(fn (Get $get): bool => 
        in_array($get('subscription_type'), ['monthly', 'annual'])
    )

The live() method triggers a server update when the field changes. The visible() closure checks form state and returns whether to show the field. For truly instant show/hide without hitting the server, use visibleJs() instead.

Dependent Selects

Load options based on another field:

use Filament\Forms\Components\Select;
use Filament\Schemas\Components\Utilities\Get;

Select::make('company_id')
    ->relationship('company', 'name')
    ->searchable()
    ->live()
    ->required(),

Select::make('department_id')
    ->options(function (Get $get) {
        $companyId = $get('company_id');
        
        if (!$companyId) {
            return [];
        }
        
        return Department::where('company_id', $companyId)
            ->pluck('name', 'id');
    })
    ->searchable()
    ->required()

This pattern is everywhere in SaaS admin panels. Select a company, the department dropdown updates to show only departments from that company. If you're dealing with database optimization on these relationship queries, make sure you've indexed the foreign key columns.

File Uploads with Image Editor

use Filament\Forms\Components\FileUpload;

FileUpload::make('avatar')
    ->image()
    ->disk('public')
    ->directory('avatars')
    ->visibility('public')
    ->imageEditor()
    ->imageEditorAspectRatios(['1:1'])
    ->maxSize(2048)
    ->helperText('Upload a profile picture (max 2MB)')

The imageEditor() method lets users crop and resize images right in the panel. No external tools needed. For handling larger files, check my guide on large file uploads in Laravel.

Rich Text with Tiptap

Filament uses Tiptap instead of TinyMCE:

use Filament\Forms\Components\RichEditor;

RichEditor::make('bio')
    ->toolbarButtons([
        'bold',
        'italic',
        'strike',
        'link',
        'bulletList',
        'orderedList',
        'h2',
        'h3',
    ])
    ->maxLength(65535)
    ->columnSpanFull()

I limit toolbar buttons. Most users don't need the full formatting arsenal.

Built-in Multi-Tenancy

One of Filament's strongest features for SaaS apps is built-in panel-level multi-tenancy. You can scope an entire admin panel to a tenant with a single method:

// In your PanelProvider
->tenant(Team::class)

This automatically scopes resources, handles tenant switching in the UI, and manages navigation. It pairs well with packages like Spatie's laravel-multitenancy for database-level isolation. I covered the different tenancy architecture patterns in my multi-tenancy strategies guide.

Performance Optimization

Admin panels get slow with thousands of records. Here's how I keep things fast.

Eager Loading

Modify queries in your resource:

use Illuminate\Database\Eloquent\Builder;

public static function getEloquentQuery(): Builder
{
    return parent::getEloquentQuery()
        ->with(['company', 'department'])
        ->withCount('projects');
}

This prevents N+1 queries. Use withCount() when you only need counts, way faster than loading full relationships.

Caching Expensive Calculations

use Illuminate\Support\Facades\Cache;
use Filament\Tables\Columns\TextColumn;

TextColumn::make('total_revenue')
    ->state(function ($record): string {
        return Cache::remember(
            "user.{$record->id}.total_revenue",
            now()->addHour(),
            fn () => $record->orders()->sum('total')
        );
    })
    ->money('usd')

I've used this pattern to cache expensive aggregations on dashboard widgets. Reduced load time from 2 seconds to 300ms on a panel managing hundreds of tenants.

Custom Actions

Actions are unified in v4/v5. Everything's in Filament\Actions.

Here's a practical example for a content management action:

use App\Jobs\GenerateReportJob;
use Filament\Actions\Action;
use Filament\Forms\Components\Select;
use Filament\Forms\Components\TextInput;
use Filament\Notifications\Notification;

Action::make('generateReport')
    ->label('Generate Report')
    ->icon('heroicon-o-document-chart-bar')
    ->form([
        Select::make('report_type')
            ->options([
                'monthly' => 'Monthly Summary',
                'quarterly' => 'Quarterly Review',
                'annual' => 'Annual Report',
            ])
            ->required(),
            
        TextInput::make('title')
            ->required()
            ->maxLength(255),
    ])
    ->action(function (array $data, $record): void {
        GenerateReportJob::dispatch($record, $data);
        
        Notification::make()
            ->title('Report generation started')
            ->body("Your {$data['report_type']} report will be ready soon.")
            ->success()
            ->send();
    })
    ->requiresConfirmation()
    ->modalHeading('Generate Report')
    ->modalDescription('Creates a report based on this record\'s data.')
    ->modalSubmitActionLabel('Generate')

Click the button, fill the form, dispatches a background job. User gets a notification when done. If you're dispatching jobs like this, make sure your queue infrastructure can handle the load.

Common Mistakes to Avoid

I've made these. Learn from my pain.

Using Old v3 Syntax

Don't use actions() and bulkActions(). Use recordActions() and toolbarActions(). The old methods don't exist in v4/v5.

Not Eager Loading Relationships

If your table shows company.department.name, eager load it in getEloquentQuery(). Otherwise you hit N+1 hell. I once watched a client's admin panel take 8 seconds per page load because relationships were lazily loaded.

Forgetting Form Validation

Add ->required(), ->email(), ->numeric(). Filament handles error display, but you specify rules.

Ignoring Mobile Responsiveness

Filament is responsive by default, but custom components might not be. Test on tablets. Admins use mobile devices more than you think.

Not Using Sections

Long forms overwhelm users. Break them into sections with descriptive headings.

Coming From Filament v3?

Major changes in v4/v5:

Separate Schema Files - Forms go in Schemas/. Tables go in Tables/. Your resource file stays clean.

Unified Actions Namespace - Everything's in Filament\Actions. No more hunting through separate namespaces.

Performance Improvements - Client-side JavaScript hooks (hiddenJs(), visibleJs(), afterStateUpdatedJs()) eliminate unnecessary Livewire roundtrips.

Tiptap Rich Editor - TinyMCE is gone. If you customized TinyMCE heavily, you'll need to rewrite for Tiptap.

New Methods:

• live() replaces reactive()
• recordActions() replaces actions()
• toolbarActions() replaces bulkActions()

Check the upgrade guide for the complete list.

Filament v5 specifically adds Livewire v4 support with non-blocking polling and parallel wire:model.live requests. The upgrade from v4 to v5 is automated: composer require filament/upgrade:"^5.0" -W --dev && vendor/bin/filament-v5.

When to Use Filament

Perfect for:

• Internal admin panels with controlled user bases
• CRUD-heavy applications (schools, inventory, CRM)
• SaaS admin dashboards (with built-in multi-tenancy)
• Projects where rapid development beats pixel-perfect design
• Teams comfortable with Livewire and Tailwind

Skip it for:

• Public-facing interfaces (Filament is for admins)
• Heavy custom JavaScript requirements (Livewire has limits)
• Non-Laravel projects
• Teams unwilling to learn Livewire

In those cases, build with Inertia.js and Vue/React instead. I covered that stack in my Laravel + Vue 3 SPA guide.

Real-World Production Tips

From running admin panels across multiple SaaS apps:

Add Activity Logging - Install spatie/laravel-activitylog. Log important changes. When someone deletes all records, you'll know who and when.

Set Up Proper Permissions - Filament integrates with Laravel policies. Use them. Not everyone should delete users or modify billing settings.

Monitor Performance - Install Laravel Debugbar or Telescope. Watch for N+1 queries. I once caught a relationship query loading 500+ records per page. Fixed it with eager loading.

Customize the Dashboard - The default dashboard is boring. Add widgets showing key metrics. Admins should see total users, active subscriptions, and recent activity on their dashboard.

Use Queue Jobs for Slow Operations - If an action takes more than 2 seconds, dispatch a job. Users don't want to wait.

Try Filament Blueprint - If you use AI coding agents (Claude Code, Cursor, Copilot), Filament Blueprint feeds your agent comprehensive knowledge about Filament's components. It produces better implementation plans with exact component references and configuration chains. Works with both v4 and v5.

Frequently Asked Questions

Should I use Filament v4 or v5 for a new project?

If you're starting fresh on Laravel 12, go with v5. You'll get Livewire v4's performance improvements (non-blocking polling, parallel live updates) out of the box. If you're on an existing project with Livewire v3, v4 is perfectly fine. The Filament team is pushing features to both versions.

Can Filament handle multi-tenancy for my SaaS?

Yes. Filament has built-in panel-level multi-tenancy with ->tenant(Team::class). This handles tenant switching, resource scoping, and navigation automatically. For database-level isolation, pair it with Spatie's laravel-multitenancy package. I've used both together successfully.

How does Filament compare to Nova or Backpack?

Filament is free and open-source. Nova costs $199/site. Backpack has a free core but charges for premium features. Feature-wise, Filament matches or exceeds both for most use cases, especially for TALL stack teams. The main trade-off is that Filament requires Livewire knowledge, while Nova uses Vue.js under the hood.

What if I need complex custom pages beyond CRUD?

Filament supports custom pages, custom Livewire components, and you can mix in standard Laravel routes. I've built analytics dashboards, report generators, and onboarding wizards all within Filament panels. It's not just CRUD.

Will my v4 plugins work with v5?

Most will, but check with plugin authors. The Filament v5 upgrade is primarily a Livewire v4 bump, so plugins that don't touch Livewire internals should work. The Filament team maintains a community plugin directory where compatibility is tracked.

What's Next?

Build something.

Start with simple CRUD for one model. Get comfortable with resources, forms, and tables. Then add relationships. Then custom actions. Then widgets.

The official documentation is excellent. Seriously some of the best docs for any Laravel package.

Remember: Filament is just Laravel. If you can build Laravel apps, you can build Filament panels. It's not magic, it's well-designed abstractions over tools you know.

If you're building a SaaS and want help architecting your admin panel, or you need someone to set up multi-tenancy and permissions properly, let's talk. I've built production panels managing thousands of users across multiple products.