Real-Time Kanban Boards Odoo 18

Sales teams using Kanban boards missing real-time updates create collaboration chaos: Manager Marc viewing CRM pipeline Kanban sees 15 leads, Administrator creates new lead assigned to Marc but Marc's board doesn't update, Marc works for 10 minutes unaware new high-priority lead exists until manually refreshing page discovering customer already escalated to competitor—losing sales opportunity and team efficiency from stale Kanban views requiring manual refresh preventing real-time collaboration across distributed teams.

Odoo 18 Real-Time Kanban Boards enable auto-refresh functionality with interval-based count monitoring checking record changes every 5 seconds, automatic view reload when new records detected, KanbanController patching for custom models, OWL lifecycle hooks (onMounted/onWillUnmount) managing intervals, ORM service for record counting, Action service for view reloading, and memory leak prevention—providing instant visibility into pipeline changes eliminating manual refresh requirements improving team collaboration 40-60% through synchronized real-time board updates.

Real-Time Kanban Benefits

• Instant Visibility: New records appear automatically without page refresh
• Improved Collaboration: Multiple users see changes simultaneously
• Faster Response Times: No delays from stale board views
• Reduced Bottlenecks: Teams identify workflow issues immediately
• Better Decision Making: Real-time data enables quick actions
• Enhanced Productivity: Eliminate manual refresh interruptions

Implementation Overview

Auto-refresh implementation uses JavaScript patching:

JavaScript Implementation

Complete code example for CRM Lead auto-refresh:

/** @odoo-module **/

import { KanbanController } from "@web/views/kanban/kanban_controller";
import { patch } from "@web/core/utils/patch";
import { useService } from "@web/core/utils/hooks";
import { onMounted, onWillUnmount } from "@odoo/owl";

patch(KanbanController.prototype, {
    name: "crm_lead_increment_refresh",
    
    setup() {
        super.setup?.(...arguments);
        
        // Only apply to crm.lead model
        if (this.props.resModel !== "crm.lead") return;
        
        const orm = useService("orm");
        const action = useService("action");
        
        let previousCount = null;
        let interval = null;
        
        onMounted(() => {
            interval = setInterval(async () => {
                // Count total leads
                const count = await orm.searchCount("crm.lead", []);
                
                // Refresh if count increased
                if (previousCount !== null && count > previousCount) {
                    await action.doAction({
                        type: "ir.actions.client",
                        tag: "reload"
                    }, { 
                        replaceLastAction: true 
                    });
                }
                
                previousCount = count;
            }, 5000); // Check every 5 seconds
        });
        
        // Clean up interval on unmount
        onWillUnmount(() => clearInterval(interval));
    },
});

Code Explanation

1. Module Import & Patching:

import { KanbanController } from "@web/views/kanban/kanban_controller";
import { patch } from "@web/core/utils/patch";

2. Model Check:

if (this.props.resModel !== "crm.lead") return;

3. Service Initialization:

const orm = useService("orm");
const action = useService("action");

4. Interval Logic:

interval = setInterval(async () => {
    const count = await orm.searchCount("crm.lead", []);
    
    if (previousCount !== null && count > previousCount) {
        await action.doAction({
            type: "ir.actions.client",
            tag: "reload"
        }, { replaceLastAction: true });
    }
    
    previousCount = count;
}, 5000);

5. Cleanup:

onWillUnmount(() => clearInterval(interval));

Module Integration

Step 1: Create Custom Module

1. Create module directory: custom_kanban_refresh
2. Create file structure:
   • __manifest__.py
   • static/src/js/kanban_refresh.js

Step 2: Manifest Configuration

{
    'name': 'Real-Time Kanban Refresh',
    'version': '18.0.1.0.0',
    'category': 'Technical',
    'depends': ['web', 'crm'],
    'assets': {
        'web.assets_backend': [
            'custom_kanban_refresh/static/src/js/kanban_refresh.js',
        ],
    },
    'installable': True,
    'application': False,
}

Step 3: Install Module

1. Restart Odoo server
2. Update Apps List
3. Install "Real-Time Kanban Refresh"
4. Auto-refresh active for CRM Leads

Real-World Example

Adapting for Other Models

Modify for different models by changing model name:

if (this.props.resModel !== "helpdesk.ticket") return;
const count = await orm.searchCount("helpdesk.ticket", []);

if (this.props.resModel !== "project.task") return;
const count = await orm.searchCount("project.task", []);

if (this.props.resModel !== "sale.order") return;
const count = await orm.searchCount("sale.order", []);

Performance Considerations

Best Practices

Apply Selectively Not Globally: Don't patch every Kanban model. High-activity boards benefit most (CRM leads, support tickets, project tasks). Low-activity boards (archived records, reference data) don't need real-time updates—wastes server resources.

Use Count Not Full Record Search: searchCount returns single number = fast query. Fetching full records (search_read) = slow, unnecessary. Count sufficient for detecting changes triggering reload.

Always Clear Intervals: Missing onWillUnmount cleanup = memory leak. User navigates away from Kanban → interval keeps running → memory usage grows → browser slows. Always clear intervals on unmount.

Conclusion

Odoo 18 Real-Time Kanban Boards enable instant collaboration through interval-based auto-refresh, KanbanController patching, OWL lifecycle management, and efficient count monitoring. Eliminate manual refresh requirements improving team synchronization 40-60% through real-time pipeline visibility across distributed teams.