Introduction
Business data isn't static—it needs to be acted upon, monitored, documented, and visualized. Yet most systems treat records as passive rows of information, forcing teams to use external tools for collaboration and action. Need to trigger a specific workflow for a record? Build a separate automation interface. Want to monitor changes to important items? Set up complex notification rules. Have to document decisions or sketch out ideas? Switch to another app and lose context.
Interactive Columns bring these capabilities directly into your data. Add a Button column to trigger workflows with one click, let users Watch important records for changes, capture rich documentation with Markdown formatting, or sketch diagrams with the Whiteboard—all without leaving the record. By embedding these interactive elements where your data lives, teams can take action, stay informed, and collaborate in context, transforming static databases into dynamic workspaces where information and action flow together seamlessly.
When you add a Button column, you're not just creating a trigger—you're embedding an entire workflow launcher that understands context and executes complex processes. When you enable Watch columns, you're building a personalized notification system that keeps everyone informed without information overload. Every Interactive Column bridges the gap between viewing data and acting on it.
What are Interactive Columns?
Interactive Columns are Proma's dynamic field types that enable real-time user engagement, action triggers, and collaborative content management directly within your data structure. They transform passive data views into active workspaces where users can execute workflows, monitor changes, document decisions, and visualize concepts without switching contexts.
These columns serve as the engagement layer in your boards, turning every record into a potential action center. While Basic Columns store your data and App Columns embed business processes, Interactive Columns focus on enabling user interaction and collaboration. They're the difference between a database that holds information and a workspace that drives action.
What makes Interactive Columns special isn't just their functionality, but their contextual awareness. Each interaction happens within the context of your data—a Button knows which record triggered it, a Watch column tracks changes to specific fields, Markdown documentation stays connected to its subject, and Whiteboard sketches maintain their relationship to the data they illustrate. This contextual integration eliminates the disconnect between information and action that plagues traditional systems.
Interactive Columns also excel at reducing friction in workflows. Instead of navigating to separate interfaces, opening multiple tools, or switching between applications, users accomplish everything within their familiar board view. This proximity between data and action dramatically improves efficiency, reduces errors, and increases user adoption.
Interactive Column Types
Button Column
The Button Column transforms your datasets into command centers where any user can trigger sophisticated automations with a single click. Unlike traditional systems that require navigating to separate automation interfaces or remembering complex procedures, Button Columns put power directly where it's needed—right next to the data it affects.
Essential Configuration
Button configuration starts with defining the action. Connect to ActivePieces workflows, Proma automations, or custom scripts. Map record data to automation parameters—the button knows its context and passes relevant information automatically. Set confirmation requirements for sensitive actions, preventing accidental triggers while maintaining workflow speed.
The visual configuration shapes user experience. Choose descriptive labels that clearly communicate the action: "Generate Invoice" beats "Process". Select colors that match action types—green for creation, blue for communication, red for deletion. Position buttons strategically in your column layout, placing frequently used actions within easy reach.
How It Works
When users click a button, the column captures the entire record context—all field values, user information, and timestamp. This context passes to your automation, enabling sophisticated logic without manual data entry. The automation can update the same record, create related records, call external APIs, or trigger complex multi-step workflows.
The execution happens asynchronously, preventing interface blocking while maintaining user feedback. Progress indicators show workflow status, success messages confirm completion, and error states provide clear troubleshooting information. Every execution logs for audit trails and debugging.
Watch Column
The Watch Column creates a personalized notification system where users subscribe to changes in specific records that matter to them. Instead of drowning in global notifications or missing critical updates, team members build their own curated feed of relevant changes.
Essential Configuration
Watch columns require minimal setup but benefit from thoughtful configuration. Define which changes trigger notifications—any update, specific field changes, or status transitions. Configure notification channels, supporting email, in-app alerts, mobile push, or webhook delivery. Set notification timing—immediate for urgent changes, batched for regular updates.
The subscription model determines how users interact with watches. Enable one-click watching for simplicity, or require users to specify which changes they want to track. Support watch inheritance where watching a parent record automatically includes child records. Configure auto-watch rules—creators watch their records, assignees watch their tasks.
How It Works
Users click the watch icon to subscribe to a record. The system tracks their preference and monitors for configured changes. When triggers occur, notifications generate with full context—what changed, who changed it, old versus new values. Users access their watch list to manage subscriptions, review notification history, and adjust preferences.
The intelligent notification system prevents overload through smart batching, duplicate prevention, and quiet hours. Similar changes group together, repeated updates consolidate, and non-urgent notifications respect working hours. Users maintain control through granular preferences and easy unsubscribe options.
Markdown Column
The Markdown Column brings rich text documentation directly into your data structure, enabling formatted content creation without the complexity of traditional rich text editors.
Essential Configuration
Markdown columns balance simplicity with capability. The editor provides a clean interface with multiple ways to access formatting options.
Command Menu ('/' Trigger)
When you type '/' in the markdown editor, a command menu appears, offering quick access to various content blocks and formatting options. This slash command system enables rapid content creation without leaving the keyboard.
Text Blocks:
Headings (H1, H2, H3) - Create document hierarchy and sections
Paragraphs - Standard body text blocks
Numbered Lists - Sequential items with automatic numbering
Bullet Lists - Unordered content points
Code Blocks - Multi-line code with syntax highlighting
Media Embedding:
Images - Embed and display images inline
Videos - Include video content directly in documentation
Audio - Embed audio files for playback
Files - Attach and reference downloadable files
Other Media - Support for additional media types as needed
Text Selection Formatting Toolbar
When you select text in the editor, a contextual formatting toolbar appears above your selection, providing immediate access to text styling options.
Text Formatting Options:
Bold - Make selected text bold for emphasis
Italic - Apply italic styling for subtle emphasis
Underline - Underline text for additional highlighting
Strikethrough - Cross out text to show deletions or completed items
Code - Format selected text as inline code with monospace font
Link - Convert selected text into a hyperlink
Highlight - Apply background highlighting to make text stand out
This floating toolbar follows your selection, ensuring formatting controls are always within reach without cluttering the interface. The toolbar appears automatically when text is selected and disappears when you click elsewhere, maintaining a clean writing environment.
How It Works
Users can write using multiple approaches:
Visual Toolbar - Select text and use the formatting toolbar for visual editing
Slash Commands - Type '/' to insert blocks and apply formatting
Keyboard Shortcuts - Use standard shortcuts (Ctrl/Cmd+B for bold, Ctrl/Cmd+I for italic, etc.)
Preview Mode
The Markdown Column includes a preview section that shows how your formatted content will appear to readers. This dual-pane approach lets you:
Write in the editor while seeing real-time rendering
Switch between edit and preview modes for focused work
Verify formatting before saving
Ensure media embeds display correctly
The preview updates automatically as you type, providing immediate visual feedback on your formatting choices. This helps maintain consistency and catch formatting issues before publishing.
Whiteboard Column
The Whiteboard Column embeds infinite canvas collaboration directly into your records, enabling visual thinking without leaving your data context. Teams sketch ideas, diagram processes, annotate screenshots, and brainstorm solutions—all within the record that needs visual exploration.
Essential Configuration
Whiteboard columns provide a clean, intuitive interface with powerful drawing capabilities. The canvas opens with a comprehensive toolbar that balances simplicity with functionality, allowing users to create everything from quick sketches to detailed diagrams.
Toolbar Components
The whiteboard toolbar provides essential tools arranged for easy access:
Navigation & View Controls:
Menu (☰) - Change Canvas Background color
Lock/Unlock - Prevent or allow accidental edits to the canvas
Hand Tool - Pan and navigate around the canvas by clicking and dragging
Cursor/Select - Select, move, and manipulate existing elements
Drawing Tools:
Rectangle - Create rectangles and squares with customizable properties
Diamond - Draw diamond shapes for decision points in flowcharts
Circle - Add circles and ellipses to your diagrams
Arrow - Draw directional arrows to show flow and connections
Line - Create straight lines for connecting elements
Pen - Freehand drawing for annotations and sketches
Text (A) - Add text labels and descriptions
Image - Insert and position images on the canvas
Eraser - Remove individual elements or drawings
More Options (⋮) - Access additional tools and features
Canvas Navigation
The interface includes helpful navigation features:
Canvas Movement Instructions - "To move canvas, hold mouse wheel or spacebar while dragging, or use the hand tool"
Zoom Controls - Zoom in (+), zoom out (-), and reset to 100% view
Undo/Redo - Navigate through your action history
Action Buttons
Three primary action buttons control your whiteboard session:
Clear Canvas - Remove all content from the whiteboard (with confirmation)
Discard - Cancel changes and close without saving
Save - Save your whiteboard content to the record
How It Works
Drawing Workflow
Users open the whiteboarsd to reveal a full-screen canvas overlay. The interface provides immediate access to all tools without nested menus or complex navigation:
Select a Tool - Click any tool in the toolbar to activate it
Draw on Canvas - Click and drag to create shapes, lines, or freehand drawings
Adjust Elements - Use the select tool to move, resize, or modify existing elements
Add Annotations - Use the text tool or pen for labels and notes
Navigate Canvas - Pan using the hand tool or spacebar+drag for larger diagrams
Real-Time Collaboration
Multiple users can work on the same whiteboard simultaneously:
See other users' cursors in real-time
Watch as teammates add elements to the canvas
No conflicts or overwrites with concurrent editing
Automatic saving prevents work loss
Best Practices
Design for Action
Interactive Columns should accelerate workflows, not complicate them. Position Button columns where users naturally look for actions—typically on the right side of boards. Group related Interactive Columns together—Watch and Button columns pair well for items requiring both monitoring and action. Name columns with active verbs that describe what they do: "Send Invoice" not "Invoice", "Watch Changes" not "Monitor".
Consider the user journey when implementing Interactive Columns. Map out the complete workflow before adding columns. Identify friction points where Interactive Columns eliminate steps. For example, replacing a five-step process (find record, copy data, switch apps, create document, send email) with a single Button column that does everything.
Limit the number of Interactive Columns per board. Too many buttons create decision paralysis. Multiple Watch columns fragment attention. Several Markdown columns scatter documentation. Focus on the primary interactions needed for each board's purpose.
Optimize for Performance
Interactive Columns can impact system performance if not configured thoughtfully. Button columns that trigger heavy automations should include rate limiting to prevent overload. Implement queuing for bulk operations rather than parallel execution. Show progress indicators for long-running processes to manage user expectations.
Watch columns generate notifications that can overwhelm if unchecked. Set intelligent defaults—watch only critical field changes, batch notifications hourly, limit to working hours. Monitor notification volumes and adjust triggers if users report overload. Provide easy unsubscribe options to prevent notification fatigue.
Whiteboard columns with extensive drawings consume significant storage and bandwidth. Set reasonable canvas size limits for typical use cases. Implement auto-archiving for inactive whiteboards. Compress image data without losing visual quality. Consider pagination for boards with many whiteboard columns.
Maintain Context
The power of Interactive Columns lies in their contextual awareness. Always pass full record context to Button automations—users shouldn't need to re-enter data that already exists. Configure Watch notifications to include what changed, not just that something changed. Let Markdown columns reference other field values dynamically.
Design Interactive Columns to work together. A Button that updates status should trigger Watch notifications. Markdown documentation should reference Whiteboard diagrams. Watch columns should notify about Button execution results. This interconnection creates powerful workflows from simple components.
Document the purpose and behavior of each Interactive Column. Users should understand what a Button does before clicking. Watch subscribers should know what changes they'll be notified about. Markdown formatting guides ensure consistent documentation. Whiteboard conventions enable better collaboration.
Scale with Growth
Plan Interactive Columns for growth. Button automations that work for 10 records should handle 10,000. Watch systems that support 5 users should scale to 500. Start with simple implementations and add sophistication as needs emerge.
Version control becomes critical as Interactive Columns evolve. Track Button automation changes—who modified what and when. Maintain Markdown content history for rollback capability. Save Whiteboard snapshots at key milestones. This versioning enables safe experimentation and easy recovery.
Monitor usage patterns to optimize over time. Which Buttons get clicked most? Which records get Watched most frequently? What Markdown templates get reused? Which Whiteboard diagrams become references? Use these insights to refine and improve your Interactive Column strategy.
Common Use Cases
Approval Workflows
Columns Setup: Button (Submit for Approval, Approve, Reject), Watch (track approval status), Markdown (approval notes and conditions)
Transform manual approval processes into one-click workflows. The Submit button validates required fields, routes to appropriate approvers, and triggers notifications. Approvers click their buttons to approve or reject with comments. Watch columns keep stakeholders informed of progress. Markdown columns document approval criteria and decision rationale.
The result: approval time reduced from days to hours, complete audit trails maintained automatically, and no approvals lost in email chains.
Customer Communication Hub
Columns Setup: Button (Send Email, Schedule Call, Generate Quote), Watch (monitor customer interactions), Markdown (conversation notes)
Centralize all customer interactions in one place. Button columns trigger templated emails with personalized data, schedule calls with calendar integration, and generate quotes from current data. Watch columns alert sales teams to customer activity. Markdown columns maintain detailed conversation histories with formatting for clarity.
The result: response time improved by 60%, no customer communication missed, and complete interaction history in one place.
Project Documentation System
Columns Setup: Markdown (requirements, specifications, notes), Whiteboard (architecture diagrams, mockups), Button (Generate Report), Watch (track documentation updates)
Build comprehensive project documentation without leaving your project board. Markdown columns capture requirements with proper formatting, specifications with code examples, and meeting notes with action items. Whiteboard columns contain architecture diagrams, UI mockups, and process flows. Button columns compile everything into formatted reports. Watch columns notify team members of documentation updates.
The result: documentation always current with project status, visual and textual documentation unified, and automatic report generation for stakeholders.
Incident Response Platform
Columns Setup: Button (Escalate, Resolve, Notify Customer), Watch (monitor critical incidents), Markdown (incident timeline), Whiteboard (system diagrams)
Respond to incidents with speed and coordination. Button columns escalate to on-call engineers, mark incidents resolved, and trigger customer notifications. Watch columns ensure critical incidents get immediate attention. Markdown columns maintain detailed timelines of actions taken. Whiteboard columns diagram affected systems and failure points.
The result: mean time to resolution decreased by 45%, clear communication throughout incidents, and comprehensive post-mortems from captured data.
Design Review Process
Columns Setup: Whiteboard (design annotations), Markdown (feedback and requirements), Button (Request Review, Approve Design), Watch (track review status)
Streamline design reviews with visual and textual feedback. Whiteboard columns allow direct annotation on designs with arrows, highlights, and comments. Markdown columns capture detailed feedback with formatting and links. Button columns request reviews from specific stakeholders and record approvals. Watch columns notify designers of new feedback.
The result: review cycles shortened by 50%, feedback consolidated in one location, and clear visual communication of changes needed.
Common Mistakes to Avoid
1. Button Overload
Mistake: Adding buttons for every possible action, creating cluttered interfaces
15 buttons per record overwhelming users
Similar actions spread across multiple buttons
No clear hierarchy of importance
Solution: Limit to 3-5 primary actions per board. Group related actions in dropdown button menus. Use color and position to indicate importance. Move rare actions to automation rules rather than buttons.
2. Watch Notification Chaos
Mistake: Poorly configured Watch columns flooding users with notifications
Watching everything by default
No batching or digest options
Notifications for minor changes
Solution: Default to watching only critical changes. Enable hourly or daily digests for non-urgent updates. Define clear notification triggers. Provide granular control over what changes trigger notifications.
3. Markdown Formatting Inconsistency
Mistake: No standards for Markdown usage leading to messy documentation
Mixed formatting styles across records
Overly complex Markdown syntax
No templates or guidelines
Solution: Create Markdown style guides with examples. Provide templates for common documentation types. Train users on basic syntax. Keep formatting simple and consistent.
4. Whiteboard Performance Issues
Mistake: Unlimited whiteboard usage degrading system performance
Massive canvases with thousands of elements
High-resolution images embedded everywhere
Never archiving old whiteboards
Solution: Set reasonable canvas size limits. Compress images before embedding. Archive whiteboards after projects complete. Monitor storage usage and clean up regularly.
5. Lost Context in Automations
Mistake: Button automations that don't utilize available context
Requiring users to re-enter data that exists in the record
Generic automations that ignore record specifics
No feedback about what the automation did
Solution: Pass full record context to automations. Use conditional logic based on record data. Provide clear success/failure messages. Log automation results back to the record.
6. Ignoring User Preferences
Mistake: Forcing the same interaction patterns on all users
No option to customize notification preferences
Mandatory watching of certain records
Fixed button configurations for all roles
Solution: Allow users to customize their notification settings. Make watching optional except where critical. Configure role-based button visibility. Respect user preferences for interaction styles.
Next Steps
Combine Interactive Columns with other Proma features:
@App Columns - Complex business logic that Interactive Columns can trigger
@Automation Engine - Build sophisticated workflows triggered by Interactive Columns
@Logic Builder - Create conditions that control Interactive Column behavior
Have questions? Our team is ready to help at [email protected]