Dark mode ready

Multilingual support

Supports v5.x

Advanced Kanban

A premium Filament plugin providing production-ready, highly customizable Kanban boards with drag & drop functionality, workflow transitions, advanced filtering, and real-time search capabilities.

Tags: Panels Kit

Supported versions:

5.x 4.x

Buy for $58.00

Get support

Asmit Nepali

Documentation

Live Demo
Demo Video
Table of Contents
Introduction
Installation
Quick Start
Core Concepts
- Kanban Board Structure
- Common Configuration Options
Configuration
- Model Configuration
- Column Configuration
  - Basic Column Setup
Columns
Search & Filtering
- Search
- Filters
Actions
- Record Actions
- Column Header Actions
  - Adding Create Action to Column Headers
  - Using Action Groups for Column Headers
Advanced Features
API Reference
- Kanban Class Methods
- KanbanColumn Methods
Relational Records
- MRR (Manage Related Records) Kanban Setup
Help & Support
Conclusion

A comprehensive guide to the Advanced Kanban plugin for Filament 4.x and 5.x

#Live Demo

Try the Live Demo to explore the features of Advanced Kanban.

#Demo Video

#Table of Contents

Introduction
Installation
Quick Start
- Create a Kanban Page
- Basic Configuration
Core Concepts
- Kanban Board Structure
- Common Configuration Options
Configuration
- Model Configuration
- Column Configuration
Columns
Search & Filtering
- Search
- Filters
Actions
- Record Actions
- Column Header Actions
Advanced Features
API Reference
- Kanban Class Methods
- KanbanColumn Methods
Relational Records
- MRR (Manage Related Records) Kanban Setup
Help & Support

#Introduction

#What is Advanced Kanban?

Advanced Kanban is a premium Filament PHP plugin that provides a production-ready, highly customizable Kanban board. It enables teams to visualize workflows, move tasks between statuses with drag & drop, and enhance productivity with rich actions, search, and filtering.

#Key Features

#Core Functionality

Drag & Drop Interface: Intuitive drag-and-drop functionality for moving records between columns
Workflow Transitions: Define allowed status transitions to control record movement
Real-time Search: Search across multiple fields
Advanced Filtering: Custom filter forms with multiple field types
Pagination: Load more records per column with infinite scroll

#Advanced Capabilities

Custom Actions: Header, record, and column header actions
Customizable Cards: Custom card components with rich content display
Column Customization: Colors, icons, labels, and descriptions for columns
Record Locking: Prevent specific records from being moved
Performance Optimized: Efficient queries with caching and lazy loading
Multilanguage Support: Full translation support via Filament's translation system
Priority Support: Dedicated support for enterprise customers

#When to Use Advanced Kanban

Advanced Kanban is perfect for:

Task Management: Project task tracking, bug tracking, feature development workflows
Approval Workflows: Content approval, document review, purchase request approvals
Content Pipelines: Blog post publishing, video production, design review processes
Issue Tracking: Customer support tickets, bug reporting, feature request tracking
Any Status-Driven Process: Sales pipelines, recruitment, inventory management

#Requirements

#System Requirements

PHP: 8.2 or higher
Laravel: 11.x or higher
Filament: 4.x | 5.x (Latest)

#Installation

Welcome to Advanced Kanban - Thank you for choosing our premium solution!

#Activating Your Exclusive License

Advanced Kanban use AnyStack to provide you with payment processing, professional license management, and reliable software distribution.

During the purchasing process, AnyStack will provide you with a license key. You will also be asked by AnyStack to activate your license by providing a domain. This is usually the domain of where your final project will live. You'll use this same domain to install locally and in production. Once you have provided a domain, your license key will be activated and you can proceed with installing with composer below.

#1. Add Private Repository

First, add the Advanced Kanban private repository to your composer.json file:

{
  "repositories": [
    {
      "type": "composer",
      "url": "https://filament-advanced-kanban.composer.sh"
    }
  ]
}

#2. Install the Package

Run the following command in your project root:

composer require asmit/advanced-kanban

#3. Authentication

During installation, you will be prompted to provide authentication credentials:

Loading composer repositories with package information
Authentication required (filament-advanced-kanban.composer.sh):
Username: [your-email-address]
Password: [your-license-key]

Authentication Details:

Username: Enter the email address associated with your license
Password: Enter your license key provided by AnyStack

Example: If your license details are:

Contact email: john@example.com
License key: 8c21df8f-6273-4932-b4ba-8bcc723ef500
Activation fingerprint: example.com

You would enter:

Username: john@example.com
Password: 8c21df8f-6273-4932-b4ba-8bcc723ef500:example.com

Important Notes:

If your license policy requires a fingerprint, append it to your license key separated by a colon (:)
If no fingerprint is required, simply use your license key without the colon and fingerprint

#4. Register on Filament Panel

Register the kanban builder on your Filament panel by adding it to the plugins array:

<?php

use Asmit\AdvancedKanban\KanbanBuilder;
use Filament\Panel;

public function panel(Panel $panel): Panel
{
    return $panel
        ->plugins([
            KanbanBuilder::make()
            // Other plugins if any
        ]);
}

#5. Publish Assets

Run the following command to publish the required assets:

php artisan filament:assets

#6. Verify Installation

After completing the installation, you should be able to:

Create kanban pages using php artisan make:filament-page YourKanbanPage
Use the KanbanPage class in your Filament pages
Access all kanban-related classes and components

#Quick Start

#1. Create a Kanban Page

To add a kanban board, create a new Filament page:

php artisan make:filament-page TasksKanban

#2. Basic Configuration

The package provides a quick and easy way to set up a kanban board in your Filament admin panel. It assumes that you have title and description fields in your kanban card. Initially, it provides basic card design and functionality which includes title and description fields.

You can change these fields using the ->titleField() and ->descriptionField() methods.

Important: You must extend KanbanPage and provide the model and status field.

Note: Don't set a $view property - KanbanPage has its own view built-in.

<?php

namespace App\Filament\Pages;

use App\Models\Task;
use Asmit\AdvancedKanban\Columns\KanbanColumn;
use Asmit\AdvancedKanban\Pages\KanbanPage;
use Asmit\AdvancedKanban\Kanban;

class TasksKanban extends KanbanPage  // ← Must extend KanbanPage
{
    // Other properties like $navigationIcon, $navigationGroup, etc.

    public function kanban(Kanban $kanban): Kanban
    {
        return $kanban
            ->model(Task::class)           // ← Pass your model
            ->statusField('status')        // ← Pass the status field
            ->columns([
                KanbanColumn::make('todo')     // ← Pass required column
                    ->label('To Do'),
                KanbanColumn::make('in_progress')
                    ->label('In Progress'),
                KanbanColumn::make('completed')
                    ->label('Completed'),
            ])
            ->searchableFields(['title', 'description'])
            ->recordsPerColumn(10);
    }
}

#3. That's It!

Your kanban board is ready! The page will automatically appear in your Filament navigation and display your tasks organized by status columns.

Key Requirements:

✅ Extend KanbanPage
✅ Pass ->model(YourModel::class)
✅ Pass ->statusField('your_status_field')
✅ Don't set $view - KanbanPage has its own view

#Core Concepts

#Kanban Board Structure

A kanban board consists of:

Columns: Represent different statuses or stages in your workflow
Cards: Individual records displayed as draggable cards
Actions: Interactive elements for performing operations
Search & Filters: Tools for finding and filtering records

#Common Configuration Options

Additional configuration methods available:

#Configuration

#Model Configuration

#Setting the Model

->model(Task::class)
->model(\App\Models\Task::class)

#Status Field

->statusField('status')
->statusField('state')
->statusField('phase')

#Title and Description Fields

->titleField('title') // default title field
->titleField('name')
->titleField('subject')

->descriptionField('description') // default description field
->descriptionField('content')
->descriptionField('notes')

#Column Configuration

#Basic Column Setup

use Asmit\AdvancedKanban\Columns\KanbanColumn;

->columns([
    KanbanColumn::make('todo')
        ->label('To Do')
        ->color('gray'),
    KanbanColumn::make('in_progress')
        ->label('In Progress')
        ->color('blue'),
    KanbanColumn::make('completed')
        ->label('Completed')
        ->color('green'),
])

#Columns

#Basic Example

<?php
use Asmit\AdvancedKanban\Columns\KanbanColumn;

public function kanban(Kanban $kanban): Kanban
{
    return $kanban
        ->model(Task::class)
        ->statusField('status')
        ->columns([
            KanbanColumn::make('todo')
                ->label('To Do')
                ->color('gray'),
            KanbanColumn::make('in_progress')
                ->label('In Progress')
                ->color('blue'),
            KanbanColumn::make('completed')
                ->label('Completed')
                ->color('green'),
        ]);
}

#Column Customization

#Color Customization

KanbanColumn::make('todo')
    ->label('To Do')
    ->color('green'); // Supports hex, rgb, hsl, and Tailwind colors

#Icon Support

KanbanColumn::make('todo')
    ->label('To Do')
    -->icon(Heroicon::OutlinedRectangleStack)
    ->iconColor(Color::Red[500])
    ->iconSize(IconSize::Medium); // Use any Heroicon name

#Extra Column Header Classes

KanbanColumn::make('todo')
    ->label('To Do')
    ->extraColumnHeadingClass('text-lg font-bold'); // Add custom classes

#Column Description

KanbanColumn::make('todo')
    ->label('To Do')
    ->description('Tasks that need to be started')
    ->color('gray');

#Workflow and Allowed Transitions

Define allowed transitions between columns to control record movement:

use Asmit\AdvancedKanban\Columns\KanbanColumn;

public function kanban(Kanban $kanban): Kanban
{
    return $kanban
        ->model(Task::class)
        ->statusField('status')
        ->columns([
            KanbanColumn::make('todo')
                ->label('To Do')
                ->allowedTransitions(['in_progress']), // Can only move to 'In Progress'

            KanbanColumn::make('in_progress')
                ->label('In Progress')
                ->allowedTransitions(['todo', 'review']), // Can move back to 'To Do' or forward to 'Review'

            KanbanColumn::make('review')
                ->label('Review')
                ->allowedTransitions(['in_progress', 'completed']), // Can move back to 'In Progress' or forward to 'Completed'

            KanbanColumn::make('completed')
                ->label('Completed')
                ->allowedTransitions([]), // No transitions allowed from 'Completed'
        ]);
}

#Lock Cards

Lock cards in specific columns to prevent them from being moved:

use Asmit\AdvancedKanban\Columns\KanbanColumn;

public function kanban(Kanban $kanban): Kanban
{
    return $kanban
        ->model(Task::class)
        ->statusField('status')
        ->columns([
            KanbanColumn::make('todo')
                ->label('To Do')
                ->lockCardUsing(fn($record) => $record->id === 1), // Lock specific record

            KanbanColumn::make('completed')
                ->label('Completed')
                ->lockCardUsing(fn($record) => true), // Lock all cards in this column
        ]);
}

#Custom Lock Appearance

KanbanColumn::make('completed')
    ->label('Completed')
    ->lockCardUsing(fn($record) => true)
    ->lockedIcon('heroicon-o-lock-closed') // Use any Heroicon name
    ->lockLabel('Completed - Cannot be moved'); // Custom label for the lock icon

#Search & Filtering

#Search

#Basic Search Setup

public function kanban(Kanban $kanban): Kanban
{
    return $kanban
        ->model(Task::class)
        ->statusField('status')
        ->searchableFields(['title', 'description', 'assignedTo.name']) // ← Add searchable fields here
        ->columns([
            // Your columns here
        ]);
}

#Customizing Search Behavior

<?php
use Illuminate\Database\Eloquent\Builder;

public function kanban(Kanban $kanban): Kanban
{   
    return $kanban
        ->model(Task::class)
        ->statusField('status')
        ->applySearchUsing(function(Builder $query, string $search) {
            return $query->where('title', 'like', '%' . $search . '%')
                ->orWhere('description', 'like', '%' . $search . '%')
                ->orWhereHas('assignedTo', function($q) use ($search) {
                    $q->where('name', 'like', '%' . $search . '%');
                });
        })
        ->columns([
            // Your columns here
        ]);
}

#Loading Indicator

->enableLoadingIndicator()

#Filters

Advanced Kanban does not provide built-in filters like other Filament resources. However, you can implement custom filtering logic in your kanban page.

#Filter Indicators

->enableFilterIndicator()

#Basic Filter Example

<?php
use Filament\Forms\Components\Select;
use Illuminate\Contracts\Database\Eloquent\Builder;

public function kanban(Kanban $kanban): Kanban
{
    return $kanban
        ->model(Task::class)
        ->statusField('status')
        ->searchableFields(['title', 'description'])
        ->filterFormSchema([
            Select::make('priority')
                ->options([
                    'low' => 'Low',
                    'medium' => 'Medium',
                    'high' => 'High',
                ])
                ->placeholder('All Priorities'),
            Select::make('assigned_to')
                ->options(User::pluck('name', 'id'))
                ->placeholder('All Users'),
        ])
        ->applyFiltersUsing(function(Builder $query, array $data) {
            if (!empty($data['priority'])) {
                $query->where('priority', $data['priority']);
            }
            
            if (!empty($data['assigned_to'])) {
                $query->where('assigned_to', $data['assigned_to']);
            }
            
            return $query;
        })
        ->columns([
            // Your columns here
        ]);
}

#Tabs to Filter Kanban Records

You can use Filament tabs to scope the Kanban board query, mirroring Filament's resource tabs behavior. Define tabs with modifyQueryUsing(...), and the active tab will automatically filter the Kanban data.

Resource/Relation Manager example:

use Asmit\AdvancedKanban\Concerns\HasKanbanRelatedRecords;
use Asmit\AdvancedKanban\Contracts\HasKanban;
use Filament\Schemas\Components\Tabs\Tab;
use Illuminate\Database\Eloquent\Builder;

class ManageProjectTask extends ManageRelatedRecords implements HasKanban
{
    use HasKanbanRelatedRecords;

    public function getTabs(): array
    {
        return [
            'all' => Tab::make(),
            'complete' => Tab::make()
                ->modifyQueryUsing(fn (Builder $query) => $query->where('status', 'complete')),
            'pending' => Tab::make()
                ->modifyQueryUsing(fn (Builder $query) => $query->where('status', 'pending')),
        ];
    }

    public function kanban(Kanban $kanban): Kanban
    {
        return $kanban
            ->model(Task::class)
            ->statusField('status')
            // ... other Kanban config
        ;
    }
}

Standalone Kanban page example:

use Asmit\AdvancedKanban\Pages\KanbanPage;
use Filament\Resources\Concerns\HasTabs;
use Filament\Schemas\Components\Tabs\Tab;
use Illuminate\Database\Eloquent\Builder;

class TaskKanban extends KanbanPage
{
    use HasTabs;

    public function getTabs(): array
    {
        return [
            'All' => Tab::make('All'),
            'High Priority' => Tab::make('High Priority')
                ->modifyQueryUsing(fn (Builder $query) => $query->where('priority', 'high')),
        ];
    }

    public function kanban(Kanban $kanban): Kanban
    {
        return $kanban
            ->model(Task::class)
            ->statusField('status')
            // ... other Kanban config
        ;
    }
}

Notes:

The active tab is initialized on first load and switching tabs reloads Kanban records.
No extra wiring is needed—Advanced Kanban automatically applies the active tab's query to the Kanban data source.

#Actions

#Record Actions

#Create Action

use Asmit\AdvancedKanban\RecordAction\CreateAction;

CreateAction::make('create')
   ->schema([
       // Component schema here
    ])

#Edit Action

use Asmit\AdvancedKanban\RecordAction\EditAction;

EditAction::make('edit')
   ->schema([
       // Component schema here
    ])

#Delete Action

use Asmit\AdvancedKanban\RecordAction\DeleteAction;

DeleteAction::make('delete')
   ->icon(Heroicon::OutlinedTrash)
   ->requiresConfirmation()
   ->color('danger')

Add actions to each record using the ->recordActions() method:

<?php
use Asmit\AdvancedKanban\Kanban;
use Asmit\AdvancedKanban\RecordAction\EditAction;
use Asmit\AdvancedKanban\RecordAction\Action;
use Asmit\AdvancedKanban\RecordAction\DeleteAction;

public function kanban(Kanban $kanban): Kanban
{
    return $kanban
        ->model(Task::class)
        ->statusField('status')
        ->recordActions([
           EditAction::make('edit')
               ->model(Task::class)
               ->schema([
                   // Component schema here
                ]),
                
            DeleteAction::make('delete')
               ->icon(Heroicon::Out
               linedTrash)
               ->requiresConfirmation()
               ->color('danger'),
               
            Action::make('view')
                ->label('View')
                ->icon('heroicon-o-eye')
                ->action(fn($record) => $this->viewTask($record))
                ->openUrlInNewTab(),
        ])
        ->columns([
            // Your columns here
        ]);
}

#Using Action Groups

use Asmit\AdvancedKanban\RecordAction\Action;
use Asmit\AdvancedKanban\RecordAction\DeleteAction;
use Asmit\AdvancedKanban\Actions\ActionGroup;

public function kanban(Kanban $kanban): Kanban
{
    return $kanban
        ->model(Task::class)
        ->statusField('status')
        ->recordActions([
            Action::make('edit')
                ->label('Edit')
                ->icon('heroicon-o-pencil')
                ->action(fn($record) => $this->editTask($record)),
            ActionGroup::make([
                Action::make('view')
                    ->label('View Details')
                    ->icon('heroicon-o-eye')
                    ->action(fn($record) => $this->viewTask($record)),
                Action::make('duplicate')
                    ->label('Duplicate')
                    ->icon('heroicon-o-document-duplicate')
                    ->action(fn($record) => $this->duplicateTask($record)),
                DeleteAction::make('delete')
                    ->label('Delete')
                    ->icon('heroicon-o-trash')
                    ->color('danger')
                    ->action(fn($record) => $this->deleteTask($record)),
            ])
            ->label('More Actions')
            ->icon('heroicon-o-ellipsis-vertical')
            ->dropdownPlacement('bottom-end'),
        ])
        ->columns([
            // Your columns here
        ]);
}

#Column Header Actions

Column header actions allow you to perform operations on a per-column basis. The most common use case is adding a "Create" button to each column that pre-fills the status field.

#Adding Create Action to Column Headers

use Asmit\AdvancedKanban\Actions\CreateAction;

CreateAction::make()
    ->schema(function(array $arguments): array {
        return $this->taskForm($arguments['status']);
    })
    ->icon(Heroicon::OutlinedPlus)
    ->link()

Add actions to column headers using the ->columnHeaderActions() method:

<?php
use Filament\Actions\Action;

public function kanban(Kanban $kanban): Kanban
{
    return $kanban
        ->model(Task::class)
        ->statusField('status')
        ->columns([
            // Your columns here
        ])
        ->columnHeaderActions([
            Action::make('add_task')
                ->label('Add Task')
                ->icon('heroicon-o-plus')
                ->color('primary')
                ->action(function($arguments) {
                    // $arguments contains the current column status
                    $this->addTaskToColumn($arguments['status']);
                }),
        ]);
}

#Using Action Groups for Column Headers

use Filament\Actions\Action;
use Asmit\AdvancedKanban\Actions\ActionGroup;

public function kanban(Kanban $kanban): Kanban
{
    return $kanban
        ->model(Task::class)
        ->statusField('status')
        ->columns([
            // Your columns here
        ])
        ->columnHeaderActions([
            ActionGroup::make([
                Action::make('add_task')
                    ->label('Add Task')
                    ->icon('heroicon-o-plus')
                    ->action(fn($arguments) => $this->addTask($arguments['status'])),
                Action::make('bulk_edit')
                    ->label('Bulk Edit')
                    ->icon('heroicon-o-pencil')
                    ->action(fn($arguments) => $this->bulkEdit($arguments['status'])),
                Action::make('export_column')
                    ->label('Export Column')
                    ->icon('heroicon-o-arrow-down-tray')
                    ->action(fn($arguments) => $this->exportColumn($arguments['status'])),
            ])
            ->label('More Actions')
            ->icon('heroicon-o-ellipsis-vertical')
            ->color('gray'),
        ]);
}

#Advanced Features

#Custom Components

The Kanban board is made up of two main components: Column Headers and Cards (Records). You can customize these components by generating your own components.

#Generating Custom Components

php artisan make:kanban-components --resource=YourResource

This command will create two Blade files in the resources/views/components/kanban/your-resource/ directory:

column-header.blade.php - Custom column header component
card.blade.php - Custom card component

#Using Custom Components

<?php

namespace App\Filament\Pages;

use Asmit\AdvancedKanban\Pages\KanbanPage;

class TasksKanban extends KanbanPage
{
    protected static string $columnHeaderComponent = 'kanban.tasks.column-header';
    protected static string $cardComponent = 'kanban.tasks.card';

    public function kanban(Kanban $kanban): Kanban
    {
        return $kanban
            ->model(Task::class)
            ->statusField('status')
            ->columns([
                // Your columns here
            ]);
    }
}

#Customize Record Move Behavior

Override the handleRecordMove method in your Kanban page class:

<?php

namespace App\Filament\Pages;

use App\Models\Task;
use Illuminate\Database\Eloquent\Model;

class TasksKanban extends KanbanPage
{
    public function handleRecordMove(string $newStatus, Model $record): void
    {
        // Update the record's status
        $record->update(['status' => $newStatus]);
        
        // Log the move
        activity()
            ->performedOn($record)
            ->log("Task moved to {$newStatus}");
    }
}

#Using Hooks

#Before Record Move

public function beforeRecordMove(string $newStatus, Model $record): void
{
    // Perform actions before the record is moved
    if ($newStatus === 'completed') {
        // Validate that the task can be completed
        if (!$record->all_subtasks_completed) {
            throw new \Exception('Cannot complete task: all subtasks must be finished');
        }
    }
    
    // Log the move attempt
    \Log::info("Attempting to move task {$record->id} to {$newStatus}");
}

#After Record Move

public function afterRecordMove(mixed $oldStatus, string $newStatus, Model $record): void
{
    // Perform actions after the record is moved
    if ($newStatus === 'completed') {
        // Send notification
        $record->assignee->notify(new TaskCompletedNotification($record));
        
        // Update completion timestamp
        $record->update(['completed_at' => now()]);
    }
    
    // Log the successful move
    \Log::info("Task {$record->id} moved from {$oldStatus} to {$newStatus}");
}

#Query Modifications

#Base Query Modifications

use Asmit\AdvancedKanban\Kanban;

Kanban::make()
    ->modifyQueryUsing(function ($query) {
        return $query->where('is_active', true);
    });

#Record Query Modifications

use Asmit\AdvancedKanban\Columns\KanbanColumn;

KanbanColumn::make()
    ->modifyRecordQueryUsing(function ($query) {
        return $query->where('status', 'to_do')->orderBy('created_at', 'asc');
    });

#Render Hooks

Advanced Kanban provides render hooks that allow you to add custom views before the search and at the board footer.

#Available Hooks

KanbanRenderHook::KANBAN_SEARCH_BEFORE - Add content before the search bar
KanbanRenderHook::KANBAN_PAGE_FOOTER - Add content at the bottom of the page

#Adding an action to a component

If you have a custom action that you would like to render inside a card component, call:

{{ $this->evaluateAction($this->yourAction(), ['recordId' => $record->getKey()]) }}

#On the Kanban class

Example:

use Filament\Actions\Action;
use Filament\Forms\Components\TextInput;

public function addDocsAction(): Action
{
    return Action::make('docs')
        ->schema(function (array $arguments): array {
            return [
                TextInput::make('title')->default($arguments['recordId']),
            ];
        });
}

#In the Blade view

Example:

{{ $this->evaluateAction($this->addDocsAction(), ['recordId' => $record->getKey()]) }}

#API Reference

#Kanban Class Methods

Method	Description	Parameters
`model()`	Set the Eloquent model for the kanban board	`string\|Model $model`
`statusField()`	Set the status field name that determines column placement	`string $field`
`titleField()`	Set the title field name to display on cards	`string $field`
`descriptionField()`	Set the description field name to display on cards	`string $field`
`columns()`	Set the kanban columns configuration	`array\|Closure $columns`
`searchableFields()`	Set fields that can be searched	`bool\|Closure $fields`
`enableLoadingIndicator()`	Enable or disable loading indicator	`Closure\|bool $condition = true`
`enableFilterIndicator()`	Enable or disable filter indicator	`Closure\|bool $condition = true`
`filterFormSchema()`	Set the filter form schema	`array\|Closure $schema`
`recordActions()`	Set actions available on individual records	`array\|Closure $actions`
`columnHeaderActions()`	Set actions available in column headers	`array\|Closure $actions`
`recordsPerColumn()`	Set maximum number of records per column	`int $count`
`modifyQueryUsing()`	Modify the base query for fetching records	`Closure $callback`
`modifyRecordQueryUsing()`	Modify query for specific column records	`Closure $callback`
`applyFiltersUsing()`	Set custom filter application logic	`Closure $callback`
`applySearchUsing()`	Set custom search application logic	`Closure $callback`
`emptyStateMessage()`	Set custom empty state message	`string $title`, `string $description`

#KanbanColumn Methods

Method	Description	Parameters
`make()`	Create a new KanbanColumn instance	`string $status`
`label()`	Set the display label for the column	`string\|Closure $label`
`description()`	Set the column description	`string $description`
`icon()`	Set the column icon	`string\|Closure\|ScalableIcon $icon`
`iconColor()`	Set the icon color	`string\|Closure $color`
`hidden()`	Hide or show the column	`bool\|Closure $hidden = true`
`allowedTransitions()`	Set allowed status transitions	`array\|Closure $transitions`
`lockCardUsing()`	Set card locking condition	`string\|Closure $icon`
`lockedIcon()`	Set locked icon	`bool\|Closure\|ScalableIcon $icon = true`
`lockedLabel()`	Set locked label	`string\|Closure $label = true`
`modifyRecordQueryUsing()`	Modify query for column records	`Closure $callback`

#Relational Records

#MRR (Manage Related Records) Kanban Setup

To manage related records in a kanban board, use the MRR (Manage Related Records) feature.

#1. Create an MRR Page

php artisan make:filament-page ManageUserTasks --resource=UserResource --type=ManageRelatedRecords

#2. Implement HasKanban Interface

<?php

namespace App\Filament\Pages;

use App\Filament\Resources\UserResource;
use App\Models\Task;
use Asmit\AdvancedKanban\Concerns\HasKanbanRelatedRecords;
use Asmit\AdvancedKanban\Contracts\HasKanban;
use Asmit\AdvancedKanban\Kanban;
use Asmit\AdvancedKanban\Columns\KanbanColumn;
use Filament\Resources\Pages\ManageRelatedRecords;

class UserTasks extends ManageRelatedRecords implements HasKanban
{
    use HasKanbanRelatedRecords;  // ← Must use this trait

    protected static string $resource = UserResource::class;  // ← Set your resource
    protected static string $relationship = 'tasks';         // ← Set your relationship

    public function kanban(Kanban $kanban): Kanban
    {
        return $kanban
            ->model(Task::class)           // ← Pass your model
            ->statusField('status')        // ← Pass the status field
            ->titleField('title')
            ->descriptionField('description')
            ->columns([
                KanbanColumn::make('To Do'), // ← Pass required column
                KanbanColumn::make('In Progress'),
            ])
            ->searchableFields(['title', 'description'])
            ->recordsPerColumn(10);
    }
}

#3. That's It!

Your MRR kanban board is ready! It will show only the related records for the current parent record.

Key Requirements for MRR:

✅ Implement HasKanban interface
✅ Use HasKanbanRelatedRecords trait
✅ Set $resource to your parent resource
✅ Set $relationship to your relationship name
✅ Pass ->model(YourModel::class)
✅ Pass ->statusField('your_status_field')

⚠️ Important: This feature is not available for regular Relation Managers, only for MRR pages.

#Help & Support

#Common Issues

#Installation Problems

Issue: Package not found during installation

composer require asmit/advanced-kanban

Solution:

Ensure you have a valid license
Check your Composer configuration
Verify you're using the correct package name

Issue: Assets not loading properly

php artisan filament:assets

Solution:

Clear your application cache: php artisan cache:clear
Clear your view cache: php artisan view:clear
Ensure you've published the assets correctly

#Configuration Issues

Issue: Kanban page not appearing in navigation

Solution:

Ensure your page extends KanbanPage
Check that you've set the correct navigation properties
Verify the page is properly registered in your panel

Issue: Records not displaying in columns

Solution:

Check that your model has the correct status field
Verify the status values match your column keys
Ensure your model is properly configured

#Performance Issues

Issue: Slow loading with many records

Solution:

Use pagination with ->recordsPerColumn()
Implement proper database indexing
Consider using eager loading for relationships
Optimize your search and filter queries

#Troubleshooting Guide

#Common Error Messages

"Column not found"

Check that your column keys match the status values in your database
Ensure all required columns are defined

"Model not found"

Verify the model class exists and is properly imported
Check that the model has the required status field

#Best Practices

#Performance Optimization

Use Pagination: Limit records per column for better performance
Optimize Queries: Use eager loading for relationships
Index Your Database: Add indexes on status and search fields
Cache Results: Implement caching for frequently accessed data

#Security Considerations

Validate Inputs: Always validate user inputs in custom actions
Check Permissions: Implement proper authorization checks
Sanitize Data: Clean user data before processing
Use HTTPS: Ensure secure connections in production

#Code Organization

Separate Concerns: Keep business logic separate from presentation
Use Traits: Leverage Laravel traits for reusable functionality
Follow PSR Standards: Maintain consistent coding standards
Document Code: Add comments for complex logic

#Getting Support

#Documentation

Official Documentation
Installation Guide
Quick Start Guide
API Reference

#Community Support

GitHub Issues: Report bugs and request features
Discord Community: Join our community for discussions
Stack Overflow: Search for existing solutions

#License

Advanced Kanban is a premium plugin that requires a valid license for production use.

#Conclusion

Advanced Kanban is designed to be flexible and powerful while remaining easy to use. Whether you're building a simple task board or a complex workflow system, these features provide the tools you need to create effective kanban boards.

For more information, examples, and community support, contact at mail2asmitnepali@gmail.com.

This documentation covers all the features and capabilities of Advanced Kanban. For the most up-to-date information, please refer to the official documentation and release notes.

The author

Asmit Nepali

I’ve been crafting applications with Laravel for four years. I enjoy tinkering with Filament, pushing its limits, and making it an essential part of every project I build. I'm also the author of the FireFly Blog plugin.

Plugins

4

Stars

121

From the same author

Resized Column

This plugin allows you to resize columns in Filament tables, enhancing the user experience by providing a more flexible and customizable interface.

Upload

The Advanced PDF Upload plugin allows you to upload PDF files with preview functionality along with Filament's default file upload features. This package provides a seamless way to handle PDF uploads with customizable preview options.

Mention

The Mention plugin lets you mention users inside RichText editor, supporting both static and dynamic searches. It can extract user details like username and ID for a seamless mention experience.

Featured Plugins

A selection of plugins curated by the Filament team

View all

Custom Dashboards

$89.00

Let your users build and share their own dashboards with a drag-and-drop interface. Define your data sources in PHP and let them do the rest.

Filament

Data Lens

$99.00

Advanced Data Visualization for Laravel Filament - a premium reporting solution enabling custom column creation, sophisticated filtering, and enterprise-grade data insights within admin panels.

Padmission

Custom Fields

$79.00

Eliminate custom field migrations forever. Let your users create and manage form fields directly in Filament admin panels with 20+ built-in field types, validation, and zero database changes.

Relaticle

Advanced Tables (formerly Filter Sets)

€79.00

Supercharge your tables with powerful features like user-customizable views, quick filters, multi-column sorting, advanced table searching, convenient view management, and more. Compatible with Resource Panel Tables, Relation Managers, Table Widgets, and Table Builder!

Kenneth Sese