13.1 Multi-User Scenarios
Taibles is built for teams. Multiple users can work on the same taible simultaneously, with real-time updates ensuring everyone stays in sync. This section explains how teams collaborate effectively using Taibles.
Overview: Collaboration Features
Built for Teams
Taibles supports:
Real-Time Updates
See changes instantly as teammates work. WebSocket-powered live sync with no page refresh needed.
User Assignment
Assign rows to team members, filter to see "my tasks", and balance workload across your team.
No Conflicts
Optimistic locking prevents overwrites. Multiple users can edit simultaneously without data loss.
Real-time collaboration:
- Multiple users viewing same taible simultaneously
- Live updates via WebSocket (no page refresh)
- See changes as they happen
- No conflicts or data loss
User assignment:
- Assign rows to specific users
- Filter to see "my tasks"
- Workload distribution
- Clear ownership
Transparent operations:
- See execution progress in real-time
- Track status changes live
- Clear visual indicators
- Coordinated workflow
Part 1: Real-Time Collaboration
How It Works
WebSocket-powered live updates:
When any user makes a change:
- The change is sent to the Taibles server
- Server saves to database
- Server broadcasts update to all connected users
- Everyone sees the change within milliseconds
No page refresh needed - Changes appear instantly for all users
What Updates in Real-Time
Cell state changes:
Watch Execution Progress in Real-Time
All users see the same states as cells execute
When execution starts, everyone sees the progression:
- Cell shows "Queued" with clock icon (amber)
- Cell shows "Running" with spinning gear (green)
- Cell shows "Done" with checkmark (green)
- All users see each state change instantly
All within 100ms - Real-time batching for performance
Manual edits:
Manual Edits Sync Instantly
When someone edits a cell, everyone sees the update immediately
When someone edits a cell:
- User types and saves
- Cell flashes briefly to show update
- All other users see the new value immediately
- Cell flashes for them too
Row additions:
New Rows Appear for Everyone
When someone adds a row, all users see it instantly
| ID | Task Name | Status |
|---|---|---|
| 1 | Task 1 | Done |
| 2 | Task 2 | Done |
| 3 | Task 3 | In Progress |
When someone adds a row:
- Row appears at bottom for everyone
- All users can start working on it immediately
- No coordination needed
Column changes:
Column Changes Appear Instantly
When an admin adds a column, all users see it without refresh
When an admin adds or modifies a column:
- Column appears in grid for all users
- Configuration updates apply immediately
- No refresh needed
Automation updates:
Automation Updates in Real-Time
When a trigger fires, all users see the new row and execution progress
| ID | Customer | Enrich Data | Lead Score |
|---|---|---|---|
| 1 | John Doe | ✓ Done | ✓ Done |
| 2 | Jane Smith | ✓ Done | ✓ Done |
When a trigger fires (like a webhook):
- New row created and visible to all
- Cells start calculating
- Everyone sees execution progress live
- States update in real-time: Queued → Running → Done
Collaborative Viewing
Scenario: Marketing Team Reviews Leads
Setup:
Taible: Inbound Leads (1,000 rows)
Team:
- Sarah (Manager) - Reviewing all leads
- Mike (Sales Rep) - Working on assigned leads
- Lisa (Sales Rep) - Working on assigned leadsSarah's view:
- No filters applied (sees all 1,000 leads)
- Watches new leads arriving from webhook
- Monitors lead scores calculating
- Sees status updates from team
Mike's view:
- Filter: Assigned To = Mike
- Sees: 47 leads assigned to him
- Updates "Contacted" status
- All changes visible to everyone instantly
Lisa's view:
- Filter: Assigned To = Lisa
- Sees: 53 leads assigned to her
- Adds notes to "Notes" column
- All changes visible to everyone instantly
💡 Real-Time Benefits
✅ Status updates visible immediately
✅ Notes appear as soon as saved
✅ No refresh needed
✅ No conflicts or overwrites
No Conflicts, No Overwrites
Optimistic locking prevents conflicts:
Solution: Protected Changes
Initial State
User A
Loads taible (Version 1)
Modifies Column X
User B
Loads taible (Version 1)
Modifies Column Y
User A saves first
User B tries to save
System detects version mismatch (User B still has Version 1, but current is Version 2)
User B refreshes and retries
1. Refreshes page, sees User A's changes
2. Makes Column Y changes again to Version 2
Scenario: Two users edit same row
Initial state:
- Row 1: Status = "New", Notes = ""
User A starts editing:
- Changes Status to "Contacted"
- Not saved yet, still typing
User B starts editing:
- Adds Notes: "Called, left voicemail"
- Saves immediately
User A saves:
- Status becomes "Contacted"
Final state:
- Row 1: Status = "Contacted", Notes = "Called, left voicemail"
- Both changes preserved!
Why it works:
- Each field updated independently
- Version checking prevents overwrites
- Last write wins per field
- No data loss
💡 Edge Case
Real-Time State Indicators
Column headers show execution status:
Column Headers Show Live Status
Click the header to navigate to the first active cell
The column header displays live counts:
- Running: 3 (with spinning gear icon)
- Queued: 47 (with clock icon)
- Failed: 2 (with error icon)
Click the header → Navigates to first running/queued cell
All users see same indicators in real-time
Individual cells show execution states:
| State | Visual | Icon | When You See It |
|---|---|---|---|
| Idle | Idle | — | Cell not yet calculated |
| Queued | Queued | 🕐 | Waiting to execute |
| Running | ⚙️ Running | ⚙️ | Currently executing |
| Done | Done | ✓ | Successfully completed |
| Failed | Failed | ⚡ | Execution error |
| Rate Limited | Rate Limited | ⏸️ | Throttled by rate limit |
| Skipped | Skipped | ⊘ | Condition not met |
| State | Badge Color | Icon | When You See It |
|---|---|---|---|
| Idle | Gray | None | Cell not yet calculated |
| Queued | Amber | Clock | Waiting to execute |
| Running | Green | Spinning gear | Currently executing |
| Done | Green | Checkmark | Successfully completed |
| Failed | Red | Lightning bolt | Execution error |
| Rate Limited | Yellow | Pause | Throttled by rate limit |
| Skipped | Gray | Circle-slash | Condition not met |
All users see state changes as they happen
Performance and Scalability
How Taibles handles many users:
Batching
Efficient Updates
Optimized Rendering
Batching (100ms window):
- Multiple updates grouped together
- Sent as single WebSocket message
- Reduces network traffic
- Smooth UI updates
Efficient updates:
- Only changed data sent
- Not entire grid
- Minimal bandwidth usage
- Fast even with slow connections
Optimized rendering:
- Only visible cells rendered
- Smooth scrolling
- No performance degradation
- Handles 10,000+ row taibles
Result: Feels fast even with 10+ simultaneous users
Use Cases for Real-Time Collaboration
1. Team Dashboard Monitoring
Team Dashboard Monitoring
Support team monitors ticket queue on wall-mounted display
📋 Setup
- • New tickets arrive (webhook)
- • Agents assign themselves
- • Status updates live
- • SLA timers countdown
✨ Benefits
Scenario: Support team monitors ticket queue
Setup:
Taible: Support Tickets
Displayed on: Wall-mounted monitor
Updates in real-time:
- New tickets arrive (webhook)
- Agents assign themselves
- Status updates (open → in-progress → closed)
- SLA timers countdownBenefits:
- Everyone sees current state
- No manual refresh
- Immediate visibility of new tickets
- Team coordination
2. Campaign Performance Tracking
Campaign Performance Tracking
Marketing team watches live campaign results together
📋 Setup
- • Campaign manager
- • Data analyst
- • Executive
- • Form submissions (webhook)
- • Lead scoring calculations
- • Conversion tracking
✨ Benefits
Scenario: Marketing team watches campaign results
Setup:
Taible: Campaign Responses
Multiple users watching simultaneously:
- Campaign manager
- Data analyst
- Executive
Updates in real-time:
- Webhook from form submissions
- Lead scoring calculations
- Conversion trackingBenefits:
- Live performance metrics
- Immediate issue detection
- Collaborative decision-making
- Celebrate wins together
3. Approval Workflows
Approval Workflows
Content approval pipeline with real-time handoffs
📋 Setup
- • Writers: Submit content
- • Editors: Review & approve
- • Publishers: Publish approved
- • New submissions appear
- • Approval status updates
- • Publishing status updates
✨ Benefits
Scenario: Content approval pipeline
Setup:
Taible: Content Queue
Roles:
- Writers: Submit content
- Editors: Review and approve
- Publishers: Publish approved content
Updates in real-time:
- New submissions appear
- Approval status updates
- Publishing status updatesBenefits:
- No waiting for refresh
- Clear pipeline visibility
- Fast turnaround
- Coordinated workflow
Part 2: User Assignment
Why User Assignment Matters
👤 Clear Ownership
- •"This row is Mike's responsibility"
- •No confusion about who handles what
- •Clear accountability
⚖️ Workload Distribution
- •Balance tasks across team
- •See who's overloaded
- •Fair assignment
🔍 Filtered Views
- •"Show me my tasks"
- •Focus on your work
- •Reduce noise
📊 Reporting
- •Tasks per user
- •Completion rates
- •Performance metrics
Benefits:
Clear ownership:
- "This row is Mike's responsibility"
- No confusion about who handles what
- Accountability
Workload distribution:
- Balance tasks across team
- See who's overloaded
- Fair assignment
Filtered views:
- "Show me my tasks"
- Focus on your work
- Reduce noise
Reporting:
- Tasks per user
- Completion rates
- Performance metrics
User-Select Columns
What they are:
UserSelectColumnOverview
Component placeholder - demonstrates UserSelectColumnOverview
- Manual column type (like text or number)
- Dropdown of organization users
- Single or multiple user selection
- Displays user's name
Use for:
- Assigned To (who owns this row)
- Reviewed By (who checked it)
- Approved By (who approved it)
- Created By (manual tracking)
Creating User-Select Column
Step-by-step guide:
CreateUserSelectColumnSteps
Component placeholder - demonstrates CreateUserSelectColumnSteps
Click "+ Add Column" button in toolbar
Search for "User Select" in column type list
- Icon shows users symbol
- Category: Manual column types
Click "User Select"
Configure the column:
- Column Name:
assigned_to - Label: "Assigned To"
- Description: "Team member assigned to this task"
- ☐ Allow multiple selections (check if needed)
- Column Name:
Click "Add Column"
Column appears in grid
💡 Single vs Multiple
Assigning Users to Rows
Method 1: Click cell to assign
AssignUserClickCellDemo
Component placeholder - demonstrates AssignUserClickCellDemo
Find the row you want to assign
Click the cell in "Assigned To" column
Dropdown opens showing all organization users:
- User's full name displayed
- Email shown below name
- Scrollable list
Click a user to assign them
User's name appears in the cell
All viewers see assignment immediately (real-time)
Method 2: Bulk assignment
BulkAssignmentDemo
Component placeholder - demonstrates BulkAssignmentDemo
Select multiple rows using checkboxes on the left
Right-click the selected rows
Choose "Set field value" → "Assigned To"
Select a user from the dropdown
All selected rows assigned to that user at once
Use for: Batch assignment, workload distribution
Method 3: Automated assignment (Advanced)
AutomatedAssignmentDemo
Component placeholder - demonstrates AutomatedAssignmentDemo
Use a Code column to auto-assign based on logic:
// Round-robin assignment example
def users = ['mike@company.com', 'lisa@company.com', 'sarah@company.com']
def rowNumber = data['row_number'] as Integer
def assignedUser = users[rowNumber % users.size()]
return assignedUserUse for: Load balancing, skill-based routing, automatic distribution
Filtering by Assigned User
Show only your tasks:
FilterByAssignedUserSteps
Component placeholder - demonstrates FilterByAssignedUserSteps
Step 1: Open filter panel
Click "Filter" button (funnel icon in toolbar)
Filter panel opens on the right side
Step 2: Create filter
Click "+ Add Filter" button
Configure the filter:
- Field:
assigned_to - Operator:
equals - Value: [Select your user from dropdown]
- Field:
Click "Apply"
Grid shows only your rows
Save as personal view:
SavePersonalViewDemo
Component placeholder - demonstrates SavePersonalViewDemo
Click "Save View" button (after applying filter)
Enter name: "My Tasks"
View is saved (only you see this personal view)
Switch views using view dropdown in toolbar
Result: Quick toggle between "All Tasks" and "My Tasks"
Team Workload View
See workload distribution:
TeamWorkloadViewDemo
Component placeholder - demonstrates TeamWorkloadViewDemo
Option 1: Group by assigned user
Click column header (Assigned To)
Choose "Group by this column" from menu
Grid groups rows by user:
▼ Sarah Johnson (12 tasks) - Task 1 - Task 2 ... ▼ Mike Chen (8 tasks) - Task 3 - Task 4 ... ▼ Lisa Rodriguez (15 tasks) - Task 5 - Task 6 ...See count per user at a glance
Use for: Workload balancing, capacity planning
Use Case: Support Ticket Assignment
Complete workflow example:
SupportTicketWorkflowDemo
Component placeholder - demonstrates SupportTicketWorkflowDemo
Setup:
Taible: Support Tickets
Columns:
- ticket_id (auto-generated)
- customer_email (text)
- subject (text)
- description (text)
- priority (dropdown: High/Medium/Low)
- assigned_to (user-select) ← Assignment column
- status (dropdown: New/In Progress/Resolved)
- resolution (text)Workflow:
Step 1: Tickets arrive
Webhook from support form
→ New row created
→ assigned_to = (unassigned)
→ status = "New"All agents see new ticket in real-time
Step 2: Manager assigns
Manager (Sarah):
1. Sees new ticket
2. Checks team workload
3. Assigns to Mike (least busy)
4. Clicks cell → Selects "Mike Chen"Mike sees assignment immediately (no refresh)
Step 3: Agent works ticket
Mike:
1. Applies filter: assigned_to = Mike
2. Sees his 8 tickets
3. Opens ticket, reads description
4. Updates status = "In Progress"
5. Contacts customer
6. Adds resolution notes
7. Updates status = "Resolved"All updates visible to team in real-time
Step 4: Manager monitors
Sarah:
1. Views all tickets (no filter)
2. Sees Mike's status updates live
3. Tracks SLA compliance
4. Reassigns if agent unavailable💡 Workflow Benefits
✅ Fair distribution (manager sees workload)
✅ Focus (agents see only their tickets)
✅ Transparency (team sees all activity)
✅ Real-time (no lag, no refresh)
Part 3: Comments and Notes
Current: Notes Columns
Available now:
NotesColumnsDemo
Component placeholder - demonstrates NotesColumnsDemo
Text columns for notes:
- Create a "Notes" column (text type)
- Create a "Review Comments" column (text area type)
- Create an "Internal Notes" column (text type)
Usage:
- Click cell
- Type notes
- Save (click away or press Enter)
- All users see notes immediately
Limitations:
- No threading (single text field)
- No @mentions
- No user attribution (can't see who wrote what)
- No timestamps per comment
Workaround: Manual Comment Tracking
ManualCommentTrackingDemo
Component placeholder - demonstrates ManualCommentTrackingDemo
Pattern for tracking who wrote what:
Create a "Comments" text area column and use this format:
[2025-11-19 10:15 - Sarah] Reviewed, looks good
[2025-11-19 11:30 - Mike] Fixed issues, ready for approval
[2025-11-19 14:20 - Lisa] Approved and publishedManual format includes:
- Date and time
- User name
- Comment text
Pros: Timestamped, attributed, chronological Cons: Manual formatting, not structured
Summary: Multi-User Scenarios
You now understand how teams collaborate in Taibles:
✅ Real-Time Collaboration:
- WebSocket-powered live updates (100ms latency)
- Multiple users viewing simultaneously
- All changes visible instantly
- No conflicts, no overwrites
- Optimistic locking prevents data loss
✅ What Updates in Real-Time:
- Cell state changes (Idle → Queued → Running → Done)
- Manual edits (text, numbers, selections)
- Row additions (from users or triggers)
- Column changes (configuration updates)
- Automation updates (trigger-created rows)
✅ User Assignment:
- User-select columns (single or multiple)
- Click cell to assign
- Bulk assignment for multiple rows
- Filter to see "my tasks"
- Workload distribution visibility
✅ Practical Workflows:
- Support ticket assignment
- Campaign monitoring
- Approval workflows
- Team dashboards
- Collaborative data entry
✅ Current Features & Limitations:
- Notes: Basic text columns now
- User tracking: Manual timestamp format
- Workload views: Grouping available now
Real-World Collaboration Patterns
Pattern 1: Manager + Team Members
ManagerTeamPattern
Component placeholder - demonstrates ManagerTeamPattern
Manager: Assigns tasks, monitors progress, reassigns as needed
Team: Filters to "my tasks", updates status, adds notes
Everyone: Sees real-time updates, no coordination overheadPattern 2: Pipeline with Handoffs
PipelineHandoffPattern
Component placeholder - demonstrates PipelineHandoffPattern
Stage 1 (Sarah): Receives, qualifies, assigns to stage 2
Stage 2 (Mike): Enriches, analyzes, assigns to stage 3
Stage 3 (Lisa): Reviews, approves, marks complete
Handoffs: Visible in real-time, no email neededPattern 3: Distributed Team
DistributedTeamPattern
Component placeholder - demonstrates DistributedTeamPattern
Multiple time zones, some asynchronous work
Real-time updates when overlap
Filter to see what changed since you last looked
Status updates propagate without meetingsNext Steps
You've completed Section 13.1: Multi-User Scenarios! You now know:
- How real-time collaboration works (WebSocket, no refresh)
- What updates in real-time (cells, rows, columns, automations)
- How to assign users to rows (user-select columns)
- How to filter by assigned user ("my tasks")
- Practical workflows for team collaboration
Next: Section 13.2: Permissions & Access Control → Learn how Taibles handles user roles, permissions, and data security.
Let's master access control!