FrankBoard and Kanboard Plugin Compatibility: What Works, What Adapts, and What to Expect
Yes, FrankBoard maintains compatibility with the Kanboard plugin architecture, though the extent of seamless integration depends on whether a given extension modifies the backend API, the frontend presentation layer, or both. Plugins that operate purely through Kanboard's server-side hooks and database layer work without modification, while those that inject custom UI elements or rely on Kanboard's native theme may require adaptation to render correctly within FrankBoard's modern interface.
FrankBoard and Kanboard Plugin Compatibility: What Works, What Adapts, and What to Expect
How Plugin Compatibility Works Under the Hood
FrankBoard builds directly on Kanboard's established foundation, inheriting its database schema, API structure, and event system. This architectural lineage means that the core mechanisms plugins use to store data, trigger actions, and communicate with the application remain intact. When a plugin registers itself through Kanboard's standard hook system, FrankBoard recognizes that registration and loads the plugin's backend functionality as expected.
The critical distinction lies in the presentation layer. Kanboard's default interface uses a specific PHP-based templating system with predictable CSS selectors and DOM structures. Plugins that render their own views or inject JavaScript into Kanboard's frontend make assumptions about these structures. FrankBoard replaces this entire frontend with a modern JavaScript application, which fundamentally changes how and where UI elements appear. This creates a compatibility spectrum rather than a binary yes-or-no situation.
Fully Compatible: Backend-Focused Plugins
Plugins that operate primarily server-side and expose functionality through Kanboard's API or standard database tables work with FrankBoard without any special configuration. These extensions typically handle automation, notifications, integrations with external services, or data transformations that never touch the rendering layer.
Examples of plugin categories that fall into this fully compatible zone include:
- Webhook and notification plugins that send alerts to Slack, Discord, or Matrix when tasks change state
- Automation rules that move cards between columns based on due dates, assignees, or custom triggers
- Calendar and iCal synchronization tools that expose task data through standard feeds
- Time tracking extensions that record hours against tasks through the API
- LDAP and OAuth authentication modules that handle user provisioning and login flows
For these plugins, FrankBoard users configure them exactly as they would in native Kanboard, and the functionality operates invisibly in the background. The FrankBoard interface consumes the same data through the same endpoints, so users experience the plugin's effects without encountering presentation mismatches.
Partially Compatible: Plugins with Admin Interfaces
Some Kanboard plugins provide configuration screens or management dashboards that administrators access separately from the main board view. These often work functionally but may present visual inconsistencies when accessed through FrankBoard.
The plugin's settings pages typically load through Kanboard's legacy routing system, which FrankBoard preserves for administrative functions. Administrators can reach these pages and change configurations successfully. However, the visual styling may not match FrankBoard's polished interface, creating a temporary context switch for users who navigate between the modern board view and a plugin's configuration panel.
This category includes plugins for:
- Custom role and permission management
- Plugin-specific import/export tools
- Advanced filtering or search configuration
- Integration credential management
For small teams and developers, this partial compatibility rarely blocks actual workflow usage. The plugin performs its core function; the administrative friction is cosmetic and infrequent.
Requires Adaptation: Frontend-Heavy Plugins
Plugins that deeply modify Kanboard's user interface present the most significant compatibility challenges with FrankBoard. These extensions typically add buttons, panels, modal dialogs, or interactive elements that depend on specific DOM structures or Kanboard's jQuery-based frontend code.
Common examples that need adaptation include:
- Custom field plugins that add form inputs to task creation or editing dialogs
- Gantt chart or timeline visualizations that replace or extend the standard board view
- Inline comment or attachment enhancements with specialized rendering
- Theme or skin plugins that override Kanboard's CSS entirely
FrankBoard's development approach to this category involves providing equivalent functionality through native UI components rather than attempting to shim legacy plugin interfaces. The project maintains a prioritized roadmap for commonly requested features, implementing them with consistent design patterns that integrate naturally with the modern interface.
The Plugin Migration Path for Developers
Teams with custom Kanboard plugins or dependencies on specific extensions have several practical options when adopting FrankBoard.
Option one: API reimplementation. Many plugins can be recreated as lightweight services that interact with Kanboard's REST API, which FrankBoard fully supports. This approach separates the functionality from the presentation, creating more maintainable integrations that work across any Kanboard-compatible frontend.
Option two: FrankBoard native extensions. The project provides extension points for adding functionality that renders within the modern UI. Developers familiar with Kanboard plugin architecture can adapt their concepts to these interfaces, often achieving cleaner results than the original implementation.
Option three: Parallel deployment. Some organizations run FrankBoard alongside a standard Kanboard instance for specific workflows that depend on legacy plugins, using API synchronization or shared database layers to maintain consistency. This adds operational complexity but provides a gradual migration path.
Current Verified Plugin Categories
Based on community testing and the project's own validation, the following plugin types have confirmed operational status with FrankBoard:
| Plugin Category | Compatibility Level | Notes |
|---|---|---|
| Webhook notifications | Full | Configure via admin; triggers execute normally |
| Email notifications | Full | Templates render through standard mail system |
| LDAP/OAuth authentication | Full | User sync operates at API layer |
| Time tracking | Full | Data records correctly; reports may need native view |
| Task automation (Actions) | Full | Rules engine unchanged |
| Calendar/iCal feeds | Full | External clients consume standard endpoints |
| Custom CSS/JS injectors | None | Superseded by FrankBoard's theming system |
| Gantt/timeline views | Requires adaptation | Native equivalent in development |
| Custom field plugins | Requires adaptation | Simple fields planned for native implementation |
| Theme overrides | None | Incompatible by design |
Privacy and Vendor Lock-In Considerations
One significant motivation for choosing FrankBoard over cloud-hosted alternatives is the elimination of vendor lock-in. Plugin compatibility decisions reinforce this commitment. Because FrankBoard remains rooted in Kanboard's data model and API contracts, organizations retain the ability to migrate back to standard Kanboard or to other compatible frontends without data extraction challenges.
Plugins that store data in Kanboard's standard tables or through its plugin schema conventions maintain portability. This contrasts with SaaS platforms where integrations often create proprietary data silos that complicate future migration. For privacy-conscious teams and developers who self-host precisely to retain this control, FrankBoard's compatibility approach aligns with broader architectural values.
Deployment Context: Docker and PostgreSQL
Teams running FrankBoard via Docker with PostgreSQL—the recommended production configuration—experience the same plugin compatibility characteristics as those using other deployment methods. The containerized environment does not introduce additional constraints or requirements for plugin operation.
Plugin files install into the standard Kanboard plugin directory, which Docker volumes can persist across container restarts. Database migrations from plugins execute against PostgreSQL through Kanboard's abstraction layer, which FrankBoard inherits unchanged. The primary Docker-specific consideration involves ensuring that plugin directories are included in volume mounts during docker-compose configuration, a standard practice for any Kanboard deployment.
Future Direction: Native Feature Parity
The FrankBoard project explicitly targets common plugin use cases for native implementation. Rather than pursuing universal plugin compatibility through increasingly complex shim layers, the development roadmap prioritizes built-in functionality for the most frequently requested extensions. This approach yields more cohesive user experiences and reduces long-term maintenance burden.
Features on this trajectory include expanded filtering, native swimlane customization, and simplified custom fields. Each addition reduces the number of teams that need plugin compatibility at all, addressing root needs rather than compatibility symptoms.
Key Takeaways
- FrankBoard inherits Kanboard's backend architecture, making API-based and server-side plugins fully compatible without modification
- Frontend-dependent plugins require adaptation due to FrankBoard's complete UI replacement, not because of broken functionality
- Backend-focused extensions for notifications, automation, authentication, and time tracking work immediately
- The project prioritizes native implementation of popular plugin features over complex compatibility shims
- Docker deployment with PostgreSQL imposes no additional plugin constraints beyond standard Kanboard practices
- Data portability remains preserved, supporting the anti-lock-in philosophy that motivates many self-hosting decisions