Visual Automation Builder Guide

Create powerful AI workflows without code using GreenMonkey's visual automation builder.

Introduction

The Visual Automation Builder allows you to:

Design workflows with drag-and-drop
Connect multiple AI models and tools
Process data through visual pipelines
Deploy automations instantly
Share and monetize workflows

Getting Started

Accessing the Builder

Navigate to Dashboard → Workflows
Click "Create New Workflow"
Choose template or start blank

Interface Overview

┌─────────────────────────────────────────────────────────────┐
│ Toolbar                                    [Save] [Test] [Deploy] │
├─────────────┬───────────────────────────────────────────────┤
│            │                                                 │
│   Node     │              Canvas Area                       │
│  Palette   │                                                │
│            │        (Drag nodes here to build)              │
│            │                                                 │
│   ┌─────┐  │                                                │
│   │Input│  │                                                │
│   └─────┘  │                                                │
│   ┌─────┐  │                                                │
│   │ AI  │  │                                                │
│   └─────┘  │                                                │
│   ┌─────┐  │                                                │
│   │Logic│  │                                                │
│   └─────┘  │                                                │
│            │                                                 │
└─────────────┴───────────────────────────────────────────────┘

Node Types

Input Nodes

Text Input

Type: input/text
Description: Manual text entry or variable
Config:
  - placeholder: string
  - default_value: string
  - multiline: boolean
Output: string

File Upload

Type: input/file
Description: Upload files for processing
Config:
  - accepted_types: array
  - max_size: number
  - multiple: boolean
Output: file object or array

API Webhook

Type: input/webhook
Description: Receive data from external services
Config:
  - method: GET/POST
  - headers: object
  - authentication: string
Output: request payload

Database Query

Type: input/database
Description: Fetch data from database
Config:
  - connector: MCP connector ID
  - query: SQL string
  - parameters: array
Output: query results

Processing Nodes

AI Processor

Type: processor/ai
Description: Process data with AI models
Config:
  - provider: openai/anthropic/google
  - model: model name
  - prompt: prompt template
  - temperature: 0-1
  - max_tokens: number
Input: any
Output: AI response

Data Transformer

Type: processor/transform
Description: Transform data structure
Config:
  - operation: map/filter/reduce
  - expression: JavaScript/JSONPath
Input: array/object
Output: transformed data

Text Processor

Type: processor/text
Description: Text manipulation
Config:
  - operation: split/join/replace/extract
  - pattern: regex or string
  - options: operation-specific
Input: string
Output: processed string

Logic Nodes

Conditional Branch

Type: logic/condition
Description: Route based on conditions
Config:
  - conditions: array of rules
  - default_path: boolean
Input: any
Output: matched branch

Loop

Type: logic/loop
Description: Iterate over data
Config:
  - type: for/while/forEach
  - max_iterations: number
Input: array/number
Output: accumulated results

Merge

Type: logic/merge
Description: Combine multiple inputs
Config:
  - strategy: concat/merge/zip
  - wait_for_all: boolean
Input: multiple
Output: combined data

Output Nodes

API Call

Type: output/api
Description: Send data to external API
Config:
  - url: endpoint URL
  - method: HTTP method
  - headers: object
  - body_template: template
Input: any
Output: API response

File Save

Type: output/file
Description: Save results to file
Config:
  - format: json/csv/txt/pdf
  - filename_template: string
  - destination: local/s3/drive
Input: any
Output: file URL

Email Send

Type: output/email
Description: Send email with results
Config:
  - to: email addresses
  - subject: template
  - body: HTML template
  - attachments: boolean
Input: any
Output: send confirmation

Building Your First Workflow

Example: Blog Post Generator

Let's build a workflow that generates SEO-optimized blog posts:

graph LR
    A[Topic Input] --> B[Keyword Research]
    B --> C[Outline Generator]
    C --> D[Content Writer]
    D --> E[SEO Optimizer]
    E --> F[Save Output]

Step 1: Add Input Node

Drag Text Input node to canvas:

{
  id: "topic-input",
  type: "input/text",
  config: {
    placeholder: "Enter blog topic",
    label: "Blog Topic"
  }
}

Step 2: Add AI Nodes

Add AI Processor for keyword research:

{
  id: "keyword-research",
  type: "processor/ai",
  config: {
    provider: "openai",
    model: "gpt-4",
    prompt: `Generate 10 SEO keywords for the topic: {{input}}

    Format as JSON array of objects:
    [{"keyword": "...", "volume": "...", "difficulty": "..."}]`
  }
}

Step 3: Connect Nodes

Click and drag from output port to input port:

connections: [
  {
    source: 'topic-input',
    sourceHandle: 'output',
    target: 'keyword-research',
    targetHandle: 'input',
  },
];

Step 4: Test Workflow

Click Test button
Enter sample topic
View results at each node
Debug any issues

Advanced Features

Variables and Context

Use variables throughout workflow:

// Set variable
{
  {
    setVar('keywords', node.output);
  }
}

// Use variable
{
  {
    getVar('keywords')[0].keyword;
  }
}

// Global context
{
  {
    workflow.id;
  }
}
{
  {
    workflow.name;
  }
}
{
  {
    execution.timestamp;
  }
}
{
  {
    user.email;
  }
}

Error Handling

Add error paths to nodes:

graph TD
    A[API Call] -->|Success| B[Process Data]
    A -->|Error| C[Error Handler]
    C --> D[Retry Logic]
    D -->|Max Retries| E[Send Alert]
    D -->|Retry| A

Configuration:

{
  id: "api-call",
  type: "output/api",
  config: {
    // ... api config
  },
  errorHandling: {
    retry: {
      attempts: 3,
      backoff: "exponential",
      delay: 1000
    },
    onError: "error-handler-node"
  }
}

Conditional Logic

Create dynamic flows:

{
  id: "content-router",
  type: "logic/condition",
  config: {
    conditions: [
      {
        path: "$.wordCount",
        operator: ">",
        value: 2000,
        output: "long-form"
      },
      {
        path: "$.wordCount",
        operator: "<=",
        value: 2000,
        output: "short-form"
      }
    ]
  }
}

Parallel Processing

Process multiple items simultaneously:

{
  id: "parallel-processor",
  type: "logic/parallel",
  config: {
    maxConcurrency: 5,
    timeout: 30000,
    continueOnError: true
  }
}

Workflow Templates

Content Generation Pipeline

{
  "name": "Content Generation Pipeline",
  "description": "Generate various content types from a single topic",
  "nodes": [
    {
      "id": "topic",
      "type": "input/text",
      "position": { "x": 100, "y": 200 }
    },
    {
      "id": "splitter",
      "type": "logic/parallel",
      "position": { "x": 300, "y": 200 }
    },
    {
      "id": "blog-writer",
      "type": "processor/ai",
      "config": {
        "prompt": "Write a 1000-word blog post about {{input}}"
      },
      "position": { "x": 500, "y": 100 }
    },
    {
      "id": "social-writer",
      "type": "processor/ai",
      "config": {
        "prompt": "Create 5 social media posts about {{input}}"
      },
      "position": { "x": 500, "y": 300 }
    }
  ]
}

Data Processing Pipeline

{
  "name": "CSV Data Enrichment",
  "description": "Enrich CSV data with AI analysis",
  "nodes": [
    {
      "id": "csv-upload",
      "type": "input/file",
      "config": {
        "accepted_types": [".csv"],
        "parse": true
      }
    },
    {
      "id": "row-processor",
      "type": "logic/loop",
      "config": {
        "type": "forEach"
      }
    },
    {
      "id": "enrichment",
      "type": "processor/ai",
      "config": {
        "prompt": "Analyze this data and add insights: {{row}}"
      }
    },
    {
      "id": "save-results",
      "type": "output/file",
      "config": {
        "format": "csv",
        "filename": "enriched_{{timestamp}}.csv"
      }
    }
  ]
}

MCP Integration

Using MCP Connectors

Add MCP nodes to workflows:

{
  id: "database-fetch",
  type: "mcp/connector",
  config: {
    connector: "mcp-postgresql",
    action: "query",
    params: {
      query: "SELECT * FROM customers WHERE created_at > {{date}}"
    }
  }
}

Available MCP Nodes

Database queries
API integrations
File operations
Communication tools
Custom connectors

Testing and Debugging

Test Mode Features

Step-by-step execution - Run node by node
Breakpoints - Pause at specific nodes
Variable inspection - View all variables
Mock data - Test with sample inputs
Error simulation - Test error paths

Debug Panel

// View execution logs
{
  timestamp: "2024-03-20T10:15:30Z",
  node: "keyword-research",
  status: "completed",
  duration: 1234,
  input: { topic: "AI trends" },
  output: { keywords: [...] },
  tokens: { prompt: 150, completion: 200 }
}

Performance Monitoring

Track workflow metrics:

Execution time per node
Token usage (AI nodes)
API call latency
Error rates
Cost estimation

Deployment

Publishing Workflows

Test thoroughly - Run multiple test cases
Add documentation - Describe inputs/outputs
Set permissions - Public/private access
Version control - Tag stable versions
Publish - Make available to users

Workflow Settings

Workflow Configuration:
  name: 'SEO Content Generator'
  version: '1.2.0'
  description: 'Generate SEO-optimized content'

  triggers:
    - type: manual
    - type: webhook
      config:
        path: '/webhooks/content-gen'
    - type: schedule
      config:
        cron: '0 9 * * MON'

  permissions:
    execute: ['owner', 'team']
    view: ['public']

  pricing:
    model: 'per-execution'
    price: 0.10

  limits:
    max_execution_time: 300
    max_nodes: 50

Monetization

Selling Workflows

Create workflow products:

Package workflow - Include documentation
Set pricing - One-time or usage-based
Add examples - Show sample outputs
Create listing - Rich description
Provide support - Help users succeed

Pricing Models

One-Time Purchase:
  - Full workflow access
  - Modifications allowed
  - Updates included
  - Price: $49-299

Usage-Based:
  - Pay per execution
  - API key required
  - Usage tracking
  - Price: $0.01-1.00/run

Subscription:
  - Monthly access
  - All workflows
  - Priority support
  - Price: $19-99/month

Best Practices

Workflow Design

✅ Do:

Keep workflows focused
Add clear documentation
Handle errors gracefully
Test edge cases
Optimize for performance

❌ Don't:

Create overly complex flows
Ignore error handling
Hard-code sensitive data
Skip testing
Forget about costs

Performance Optimization

Minimize AI calls - Batch when possible
Cache results - Reuse common data
Parallel processing - Use when independent
Efficient prompts - Reduce token usage
Early filtering - Process less data

Security Considerations

// Use environment variables
{
  config: {
    apiKey: "{{env.API_KEY}}"
  }
}

// Validate inputs
{
  type: "processor/validate",
  config: {
    schema: {
      type: "object",
      properties: {
        email: { type: "string", format: "email" }
      }
    }
  }
}

// Sanitize outputs
{
  type: "processor/sanitize",
  config: {
    removePersonalInfo: true,
    maskSensitiveData: true
  }
}

Troubleshooting

Common Issues

Issue	Cause	Solution
Node won't connect	Type mismatch	Check input/output types
Workflow fails	Missing config	Verify all required fields
Slow execution	Too many AI calls	Optimize prompt usage
High costs	Inefficient design	Batch operations