Skip to content
Tallyfy

Common n8n workflow examples

Practical n8n workflows for Tallyfy automation

Need ready-to-use n8n workflows that actually work? You’re in the right place. These examples show common integration patterns with Tallyfy - complete with workflow structures and configuration details you can copy directly.

Example 1: CRM to Tallyfy process automation

Automatically launch a customer onboarding process when a deal is marked as “Won” in your CRM.

Workflow components:

  1. Webhook node (or CRM-specific trigger)

    • Receives notification when deal status changes
    • Filters for “Won” status only

  2. HTTP Request node - Get customer details

    • Method: GET
    • URL: Your CRM API endpoint for customer data

  3. HTTP Request node - Launch Tallyfy process

    • Method: POST
    • URL: https://go.tallyfy.com/api/runs
    • Body:
    {
      "blueprint_id": "customer_onboarding_template_id",
      "name": "Onboarding - {{$json.customer_name}}",
      "kickoff": {
        "customer_name": "{{$json.customer_name}}",
        "email": "{{$json.email}}",
        "package": "{{$json.deal_type}}",
        "account_manager": "{{$json.assigned_to}}"
      }
    }

  4. Slack node (optional)

    • Send notification to sales team about process launch

Example 2: Form submission to multi-system update

Here’s how to update multiple systems whenever someone submits a Tallyfy form. No manual copying required.

Workflow components:

  1. Webhook node

    • Configure in Tallyfy to trigger on task completion
    • Filter for specific form-containing tasks

  2. IF node - Check task type

    • Condition: {{$json.task.blueprint_step_id}} == "form_step_id"

  3. Set node - Extract form data

    • Map Tallyfy form fields to standardized variables

  4. HTTP Request node - Update CRM

    • Method: PUT
    • URL: CRM contact endpoint
    • Map form fields to CRM fields

  5. Google Sheets node - Log submission

    • Append row with form data and timestamp

  6. Email node - Send confirmation

    • To: Form submitter
    • Include summary of submitted data

Visualizing n8n workflow patterns

This diagram shows how n8n workflows handle multi-system updates with conditional branching and retry logic.

Diagram

What to notice:

  • Parallel processing branches - The workflow updates CRM, Google Sheets, and sends emails simultaneously, reducing total execution time
  • Exponential backoff retry pattern - Failed operations retry with increasing wait times (2s, 4s, 8s) to avoid overwhelming systems
  • Conditional path handling - The IF node prevents processing tasks without forms, saving resources and preventing errors

Example 3: Scheduled process launcher with data collection

Want to launch weekly review processes that automatically gather data from your tools? This workflow does exactly that.

Workflow components:

  1. Schedule Trigger node

    • Cron expression: 0 9 * * 1 (Every Monday at 9 AM)

  2. HTTP Request node - Get sales data

    • Connect to your analytics API
    • Fetch last week’s metrics

  3. HTTP Request node - Get support tickets

    • Query helpdesk API for open tickets

  4. Code node - Process data

    const salesTotal = items[0].json.total;
    const openTickets = items[1].json.count;
    const reviewData = {
      week_ending: new Date().toISOString().split('T')[0],
      sales_total: salesTotal,
      support_tickets: openTickets,
      review_priority: openTickets > 50 ? "High" : "Normal"
    };
    return [{json: reviewData}];

  5. HTTP Request node - Launch Tallyfy process

    • Method: POST
    • URL: https://go.tallyfy.com/api/runs
    • Include collected data in kickoff fields

Example 4: Document generation from completed processes

Need PDF reports when your Tallyfy processes finish? Here’s a workflow that creates them automatically.

Workflow components:

  1. Webhook node

    • Tallyfy webhook for process completion

  2. HTTP Request node - Get process details

    • Method: GET
    • URL: https://go.tallyfy.com/api/runs/{{$json.run_id}}

  3. HTTP Request node - Get all task data

    • Method: GET
    • URL: https://go.tallyfy.com/api/tasks?run_id={{$json.run_id}}

  4. Code node - Format report data

    const tasks = $input.all();
    const reportData = {
      process_name: tasks[0].json.run.name,
      completed_date: new Date().toISOString(),
      task_summary: tasks[1].json.map(task => ({
        name: task.name,
        completed_by: task.completed_by_name,
        form_data: task.form_fields
      }))
    };
    return [{json: reportData}];

  5. HTML node - Generate HTML template

    • Create formatted report layout

  6. Convert to PDF node (or external service)

    • Convert HTML to PDF

  7. Upload to cloud storage

    • Store in Google Drive, Dropbox, or S3

Example 5: Intelligent task routing with AI

Let AI analyze your Tallyfy form responses and route tasks to the right people. Your team gets the work they’re best at - automatically.

Workflow components:

  1. Webhook node

    • Trigger on Tallyfy form submission

  2. OpenAI node (or similar AI service)

    • Analyze form content for urgency and category
    • Prompt: “Categorize this request and assign priority”

  3. Switch node - Route based on AI analysis

    • Branch for each category/priority combination

  4. HTTP Request node (multiple) - Update task assignment

    • Method: PUT
    • URL: https://go.tallyfy.com/api/tasks/{{$json.task_id}}
    • Assign to appropriate Tallyfy member based on routing

  5. Notification nodes

    • Alert assigned team member via preferred channel
n8n AI Agent node connected to OpenRouter Chat Model and Simple Memory for building intelligent workflow automations

Example 6: Human-in-the-loop workflows

Sometimes you need a human to review AI outputs or approve actions before they continue. n8n’s “Send and wait for response” nodes let you pause workflows for human input - turning hours of manual review into quick approval checks.

Real-world pattern from production:

  1. AI generates content (proposal, report, blog post)
  2. Workflow pauses with notification to Slack/Email asking for review
  3. Human reviews and responds (approve/reject/modify)
  4. Workflow continues based on the response

Workflow components:

  1. Trigger node - Start from webhook, schedule, or manual

  2. AI Agent node - Generate the content that needs review

    • Configure with appropriate LLM (Claude, GPT-4, etc.)
    • Include clear system prompts for consistent output format

  3. Slack node (Human in the Loop category)

    • Action: Send message and wait for reply
    • Send AI output with clear “Approve” / “Reject” / “Revise” instructions
    • Workflow pauses here until response received

  4. Switch node - Route based on response

    • “Approved” → Continue to next action
    • “Rejected” → Log and notify, end workflow
    • “Revise” → Loop back to AI with feedback

  5. Action nodes - Execute based on approval

    • Send proposal to client
    • Publish content
    • Update CRM records

Example use cases:

  • Review proposals before client delivery - AI drafts, human verifies pricing and scope
  • Approve AI-generated content before publishing - Catch hallucinations or tone issues
  • Validate data enrichment before CRM updates - Confirm AI matched the right company

Pro tip: You can stack multiple human-in-the-loop steps for multi-level approval workflows - just chain several “Send and wait” nodes with different reviewers.

Switch nodes for intelligent routing

The Switch node lets AI make decisions that branch your workflow into different paths. Instead of complex IF/ELSE chains, use AI classification combined with Switch routing.

Pattern:

Webhook → AI Agent (classify request) → Switch Node → Multiple specialized paths

How to configure:

  1. AI Agent node - Classify the input

    • System prompt: “Classify this request as exactly one of: URGENT, NORMAL, or LOW_PRIORITY”
    • Output should be a single keyword

  2. Switch node - Create rules for each classification

    • Mode: Rules
    • Add rule: Value equals “URGENT” → Output 0 (urgent path)
    • Add rule: Value equals “NORMAL” → Output 1 (normal path)
    • Fallback: Output 2 (low priority path)

  3. Different paths - Each output connects to specialized handling

    • URGENT: Immediate Slack alert + assign to senior staff
    • NORMAL: Standard queue + email notification
    • LOW_PRIORITY: Batch processing + weekly digest

This pattern works for:

  • Customer support ticket triage
  • Lead scoring and routing
  • Content categorization
  • Compliance checking

Best practices for n8n + Tallyfy workflows

  1. Error handling: Your workflows will fail eventually - plan for it:

    On Error: Continue (Error Output)
    → Log error details
    → Send alert notification
    → Store failed data for retry

  2. Rate limiting: Don’t hammer the APIs. Add Wait nodes between bulk operations:

    • Wait 1 second between API calls when processing many items

  3. Data validation: Check your data before sending it. Use IF nodes to validate:

    • Required fields actually exist
    • Data formats match what Tallyfy expects

  4. Workflow organization: Future you will thank present you. Use Sticky Note nodes to document:

    • Workflow purpose and triggers
    • Required credentials and configuration
    • Expected data formats

  5. Testing approach:

    • Start with Manual Trigger for testing
    • Add Set nodes with test data
    • Use Stop and Error nodes for debugging

  6. Retry settings for reliability: Configure retry behavior in workflow settings:

    • Set retry count to 2+ for AI and HTTP nodes
    • Use 5000ms (5 seconds) between retry attempts
    • This handles temporary rate limits and network blips automatically

  7. Version history awareness: n8n keeps workflow versions for 5 days:

    • Use Export as JSON for permanent backups of important workflows
    • You can restore previous versions from the workflow menu
    • Before major changes, export a backup JSON file

Debugging tips

IssueSolution
Workflow not triggeringCheck webhook is active in both n8n and Tallyfy
Data not mapping correctlyUse expression editor’s “Current Node” tab to see available data
API errorsAdd HTTP Request “Full Response” option to see detailed errors
Performance issuesSplit large workflows into sub-workflows

Advanced patterns

Parallel processing: Process multiple items at once (without breaking things). Use Split In Batches node to handle batches while respecting rate limits.

Retry logic: Sometimes things fail. Here’s smart retry with Wait and IF nodes:

  1. Set retry counter
  2. On error, increment counter
  3. Wait exponentially longer between retries (2s, 4s, 8s…)
  4. Stop after max retries reached

Data enrichment: Need more context? Chain multiple API calls to gather complete data before launching Tallyfy processes. Perfect for pulling customer history, support tickets, or sales data into one complete picture.

Ready to build? These examples give you working patterns to start from. Tweak them for your specific needs and systems.

N8N > Connecting n8n

n8n connects to Tallyfy through a dedicated community node or HTTP Request nodes enabling workflow automation with 60+ operations across blueprints processes tasks and users while supporting real-time webhook events and offering both self-hosted and cloud deployment options.

Middleware > n8n

n8n connects Tallyfy with over 400 business applications through visual workflows using a dedicated connector with 60+ operations while offering self-hosting options and AI-native automation capabilities for launching processes managing tasks and orchestrating cross-system data synchronization.

Templates > Automations

Tallyfy automations turn static workflows into adaptive processes using IF-THEN rules that automatically route tasks adjust deadlines and show or hide steps based on real-time user input and form responses.

Webhooks > Details about webhooks

Tallyfy webhooks automatically transmit JSON data to external URLs when workflow events occur at either the template level (firing on any step completion or process launch) or step level (firing only for specific task completions) and include retry logic for failed deliveries along with organizational ID headers for security validation.
Get in touch
About Tallyfy