Visual Flow Builder

Create complex automated workflows using Verk's visual flow builder. Design multi-step automation with drag-and-drop nodes, branching logic, and integrations.

Overview

The Visual Flow Builder lets you create sophisticated automation without code:

• Drag-and-drop interface: Build workflows visually
• Multiple triggers: Start flows from various events
• Conditional logic: Branch based on task properties
• Actions: Automate task updates, notifications, and integrations
• Real-time testing: Test flows before activating
• Version history: Track and roll back changes

Getting Started

Create Your First Flow

1. Navigate to Workflows

• Go to Automation → Workflows
• Click Create Workflow
• Choose Visual Flow Builder

2. Add a Trigger

• Click Add Trigger node
• Select trigger type:
• Task Created - New task in project
• Task Updated - Task property changes
• Status Changed - Task moves to new status
• Due Date Approaching - Deadline nearing
• Comment Added - New task comment
• Schedule - Time-based triggers
• Webhook - External API calls
• Configure trigger conditions

3. Add Actions

• Click + to add action node
• Select action type:
• Update Task - Change properties
• Create Task - New task from template
• Send Notification - Slack, email, push
• Assign Task - Auto-assign to team member
• Add Comment - Automated updates
• Call Webhook - External integrations
• AI Action - Use AI agent

4. Add Conditions (Optional)

• Click + and select Condition
• Set conditional logic
• Create branches for different outcomes
• Connect nodes to define flow path

5. Test and Activate

• Click Test Flow
• Review test results
• Fix any errors
• Click Activate to enable

Flow Components

Triggers

Task Triggers:

Task Created
├─ In specific project
├─ With specific label
├─ Assigned to specific person
└─ With priority level

Change Triggers:

Task Updated
├─ Status changes
├─ Priority changes
├─ Assignee changes
├─ Due date changes
└─ Custom field updates

Time Triggers:

Schedule
├─ Specific time (daily, weekly, monthly)
├─ Due date relative (1 day before, etc.)
├─ Task age (created 7 days ago)
└─ Recurring intervals

External Triggers:

Webhook Received
├─ From integration
├─ From API call
├─ From external service
└─ Custom payload

Actions

Task Actions:

• Update Task: Modify status, priority, assignee, due date, custom fields
• Create Task: Generate new task from template or values
• Delete Task: Remove task (use with caution)
• Duplicate Task: Create copy with same properties
• Move Task: Change project

Communication Actions:

• Send Notification: Slack, email, push notification
• Add Comment: Automated task updates
• @Mention: Notify specific team members
• Create Thread: Start discussion

Integration Actions:

• Call Webhook: POST to external URL
• Update Integration: Sync to Jira, Linear, etc.
• Create Calendar Event: Google Calendar, Outlook
• Post to Slack: Channel messages

AI Actions:

• Run AI Agent: Execute agent instructions
• Generate Summary: AI task summary
• Classify Task: Auto-labeling
• Analyze Sentiment: Mood detection

Conditions

Property Conditions:

If task priority = High
If task assignee = user_123
If task status = In Progress
If task due date < 7 days from now
If task has label "urgent"

Logical Operators:

AND: All conditions must be true
OR: Any condition must be true
NOT: Condition must be false

Complex Conditions:

If (Priority = High AND Assignee = John)
 OR (Label = urgent)
Then: Send Slack notification
Else: Add to backlog

Branches

Create different paths based on conditions:

Task Created
 ↓
Is Priority High?
├─ Yes → Assign to senior engineer → Notify on Slack
└─ No → Assign to team queue → Add to backlog

Multi-way Branches:

Task Status Changed
 ↓
Status is?
├─ Done → Mark calendar event complete → Notify team
├─ Blocked → Create unblock task → Notify manager
├─ In Review → Assign to QA → Add review checklist
└─ Else → Log activity

Building Complex Flows

Example: Bug Triage Automation

Goal: Automatically triage and assign bug reports

Flow Design:

Trigger: Task created with "Bug" label
 ↓
Condition: Is priority set?
├─ Yes → Continue
└─ No → AI: Analyze description for severity → Set priority
 ↓
Condition: Priority = High?
├─ Yes → Branch A: Urgent Bug Flow
│ ├─ Assign to on-call engineer
│ ├─ Post to #urgent-bugs Slack
│ ├─ Create calendar reminder
│ └─ Set due date: Today
└─ No → Branch B: Standard Bug Flow
 ├─ Add to bug triage board
 ├─ Assign to QA lead
 ├─ Set due date: +3 days
 └─ Add to next sprint

Configuration Steps:

1. Trigger: Task created + has label "Bug"
2. Condition node: Check if priority exists
3. If no priority: AI action to analyze severity
4. Condition node: Check if priority = High
5. Branch A (High): 4 parallel actions
6. Branch B (Normal): 4 sequential actions

Example: Onboarding Workflow

Goal: Automate new team member onboarding

Flow Design:

Trigger: User added to organization
 ↓
Action: Create onboarding project for user
 ↓
Parallel Actions:
├─ Create "Setup accounts" task → Due: Day 1
├─ Create "Training sessions" task → Due: Week 1
├─ Create "First project" task → Due: Week 2
└─ Send welcome email → Include links
 ↓
Wait: 1 day
 ↓
Condition: "Setup accounts" task completed?
├─ Yes → Send congratulations message
└─ No → Notify manager → Offer help
 ↓
Wait: 7 days
 ↓
Create "1-week check-in" task for manager

Example: Release Management

Goal: Coordinate release tasks across teams

Flow Design:

Trigger: Task moved to "Ready for Release"
 ↓
Actions (Parallel):
├─ Create QA testing task → Assign to QA team
├─ Create deployment checklist → Assign to DevOps
├─ Create release notes task → Assign to PM
└─ Update Linear/Jira status → "Ready for QA"
 ↓
Wait: All 3 tasks completed
 ↓
Action: Post to #releases Slack channel
 ↓
Condition: Is hotfix release?
├─ Yes → Deploy immediately → Notify stakeholders
└─ No → Schedule for next release window
 ↓
Action: Create post-release monitoring task

Advanced Features

Loops and Iterations

Repeat actions for multiple items:

For each subtask in task:
 ↓
 Check if subtask completed
 ├─ Yes → Add checkmark to summary
 └─ No → Send reminder to assignee
 ↓
All subtasks checked → Update parent task

Wait Conditions

Pause flows until conditions met:

Time-based:

• Wait 1 hour
• Wait until tomorrow 9 AM
• Wait 2 business days

Condition-based:

• Wait until task status = Done
• Wait until all subtasks completed
• Wait for comment from specific user

Variables

Store and reuse data within flows:

Variable: original_assignee = task.assignee
 ↓
Action: Reassign task to manager for review
 ↓
Wait: Manager approves (comment contains "approved")
 ↓
Action: Reassign task back to `{{ original_assignee }}`

Variable Types:

• Task properties: {{ task.title }}, {{ task.assignee }}
• User properties: {{ user.name }}, {{ user.email }}
• Custom values: Set in flow, use later
• Computed values: Math, date calculations

Error Handling

Handle failures gracefully:

Try: Send Slack notification
 ↓
Catch: Slack API error
 ↓
 Fallback: Send email instead
 ↓
 Log error for review

Error Actions:

• Retry with exponential backoff
• Execute fallback action
• Notify admin
• Log error and continue
• Halt flow and alert

Testing Flows

Test Mode

Safely test flows before activation:

1. Click Test Flow button
2. Select test trigger event:

• Use recent real event
• Create mock event
• Upload test data

3. Step through flow execution
4. Review action outcomes (no changes made)
5. Check for errors or warnings
6. Verify expected behavior

Test Results:

 Trigger matched successfully
 Condition evaluated: true
 Action: Update task (simulated)
 Action: Send Slack (dry run)
 Action: Webhook failed (connection timeout)

Debug Mode

Troubleshoot flow issues:

• Execution History: See past flow runs
• Node Logs: View detailed logs per node
• Variable Inspector: Check variable values
• Error Stack Traces: Debug failures
• Performance Metrics: Identify slow nodes

Flow Management

Versioning

Track flow changes over time:

• Auto-save: Changes saved automatically
• Version History: See all past versions
• Compare Versions: Diff between versions
• Rollback: Restore previous version
• Comments: Document changes

Organization

Keep flows organized:

Folders:

• Group related flows
• Organize by team, project, or type
• Set folder permissions

Tags:

• Label flows for easy filtering
• Examples: "production", "experimental", "deprecated"

Naming Conventions:

Good: "Auto-assign high priority bugs to on-call"
Better: "[Bugs] High Priority → On-Call Assignment"
Best: "[Bugs][Auto-Assign] High Priority → On-Call + Slack Alert"

Permissions

Control who can edit flows:

• View Only: See flow design, can't edit
• Editor: Modify and test flows
• Admin: Activate, deactivate, delete flows
• Owner: Full control + transfer ownership

Monitoring

Flow Analytics

Track flow performance:

Execution Metrics:

• Total executions
• Success rate
• Average execution time
• Failure reasons
• Most common paths

Impact Metrics:

• Tasks automated
• Time saved
• Errors prevented
• Notifications sent

Alerts

Get notified of flow issues:

Alert Conditions:

• Flow execution fails 3 times in a row
• Flow hasn't executed in 7 days (expected to run)
• Flow execution time > 30 seconds
• Error rate > 10%

Alert Channels:

• Email
• Slack
• Push notification
• Webhook

Best Practices

Flow Design

Keep It Simple:

• Start with basic flows
• Add complexity incrementally
• Break complex flows into multiple simple ones
• Document flow purpose and logic

Use Descriptive Names:

• Name each node clearly
• Add comments to explain complex logic
• Use consistent naming conventions
• Include flow purpose in title

Handle Edge Cases:

• What if task is deleted mid-flow?
• What if webhook fails?
• What if user is deactivated?
• Add error handling for all scenarios

Performance

Optimize Execution:

• Use parallel actions when possible
• Minimize wait times
• Cache repeated API calls
• Batch similar operations

Reduce Noise:

• Don't over-notify users
• Batch notifications when appropriate
• Use conditions to filter irrelevant triggers
• Respect user preferences

Maintenance

Regular Reviews:

• Audit flows quarterly
• Remove unused flows
• Update deprecated patterns
• Optimize slow flows

Documentation:

• Comment complex logic
• Maintain change log
• Document expected behavior
• Share with team

Common Patterns

Task Routing

New task → Check properties → Route to appropriate team

Escalation

Task overdue → Notify assignee → Wait 1 day → Notify manager

Approval Workflow

Task created → Request approval → Wait for approval → Execute

Data Sync

External event → Validate data → Create/update task → Sync back

Notification Batching

Collect events for 1 hour → Batch → Send single summary notification

Related Documentation

• Automation Rules - Simple if-then automation
• Integration Flows - Cross-platform workflows
• AI Agents - Intelligent automation
• Webhooks - External triggers and actions
• API Reference - Build custom actions

---

Visual flows transform complex manual processes into automated workflows, saving time and reducing errors.