Common n8n workflow examples

Practical n8n workflows for Tallyfy automation

These examples show common n8n integration patterns with Tallyfy - complete with workflow structures and configuration details you can adapt directly.

All Tallyfy API URLs require your organization ID. Replace {org_id} with your actual organization ID in every endpoint below.

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 deal status change notifications
   • 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/organizations/{org_id}/runs
   • Body:

   {
     "checklist_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)

   • Notify sales team about the process launch

Example 2: Form submission to multi-system update

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

5. Google Sheets node - Log submission

   • Append row with form data and timestamp

6. Email node - Send confirmation

   • To: Form submitter with summary of submitted data

Visualizing n8n workflow patterns

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

What to notice:

• Parallel branches - CRM, Google Sheets, and email updates run simultaneously
• Conditional path - The IF node skips tasks without forms, preventing unnecessary processing

Example 3: Scheduled process launcher with data collection

Launch weekly review processes that automatically gather data from your tools.

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 for 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/organizations/{org_id}/runs
   • Include collected data in kickoff fields

Example 4: Document generation from completed processes

Generate PDF reports automatically when Tallyfy processes finish.

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/organizations/{org_id}/runs/{{$json.run_id}}

3. HTTP Request node - Get all task data

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

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 formatted report layout

6. Convert to PDF node (or external service)

7. Upload to cloud storage - Google Drive, Dropbox, or S3

Example 5: Intelligent task routing with AI

Use AI to analyze Tallyfy form responses and route tasks to the right people 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/organizations/{org_id}/tasks/{{$json.task_id}}
   • Assign to appropriate Tallyfy member based on routing

5. Notification nodes

   • Alert assigned team member via their preferred channel

Example 6: Human-in-the-loop workflows

n8n’s “Send and wait for response” nodes pause workflows for human input - turning hours of manual review into quick approval checks.

Pattern:

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

Workflow components:

1. Trigger node - Webhook, schedule, or manual start

2. AI Agent node - Generate content that needs review

   • Configure with your preferred LLM (Claude, GPT-4, etc.)
   • Use clear system prompts for consistent output

3. Slack node (Human in the Loop category)

   • Action: Send message and wait for reply
   • Include “Approve” / “Reject” / “Revise” instructions
   • Workflow pauses until a response arrives

4. Switch node - Route based on response

   • “Approved” - continue to next action
   • “Rejected” - log, notify, and end
   • “Revise” - loop back to AI with feedback

5. Action nodes - Execute based on approval

   • Send proposal, publish content, or update CRM

Use cases:

• Review proposals before delivery - AI drafts, human verifies pricing and scope
• Approve AI content before publishing - catch hallucinations or tone issues
• Validate data enrichment - confirm AI matched the right company

You can chain multiple “Send and wait” nodes with different reviewers for multi-level approvals.

Switch nodes for intelligent routing

Use AI classification with a Switch node instead of complex IF/ELSE chains.

Pattern:

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

Configuration:

1. AI Agent node - Classify the input

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

2. Switch node - Route by classification

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

3. Specialized handling per path

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

Works well for support ticket triage, lead scoring, content categorization, and compliance checks.

Best practices for n8n + Tallyfy workflows

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

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

2. Rate limiting - add Wait nodes between bulk operations. A 1-second delay between API calls prevents throttling.

3. Data validation - use IF nodes to confirm required fields exist and formats match what Tallyfy expects before sending data.

4. Workflow organization - use Sticky Note nodes to document the workflow’s purpose, required credentials, and expected data formats.

5. Testing - start with Manual Trigger and Set nodes for test data. Use Stop and Error nodes for debugging.

6. Retry settings - set retry count to 2+ on AI and HTTP nodes with 5000ms between attempts. This handles temporary rate limits automatically.

7. Version history - n8n keeps recent workflow versions, but use Export as JSON for permanent backups before major changes.

Debugging tips

Issue	Solution
Workflow not triggering	Check webhook is active in both n8n and Tallyfy
Data not mapping correctly	Use expression editor’s “Current Node” tab to see available data
API errors	Add HTTP Request “Full Response” option to see detailed errors
Performance issues	Split large workflows into sub-workflows

Advanced patterns

Parallel processing - use the Split In Batches node to handle multiple items while respecting rate limits.

Retry logic with Wait and IF nodes:

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

Data enrichment - chain multiple API calls to gather complete data before launching Tallyfy processes. Pull customer history, support tickets, or sales data into one picture before kicking off a workflow.

Related articles

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 hundreds of business applications through visual workflows using a dedicated connector with 55 operations across 10 resources while offering self-hosting options and AI-native automation for launching processes and managing tasks.

Miscellaneous > Glossary

Tallyfy’s glossary defines every key platform term from Administrator roles and automation rules to webhooks and workflow templates so users can quickly understand concepts like templates (reusable process blueprints) and processes (running instances of those templates) along with features such as kick-off forms and conditional logic and guest access and API integrations.

Webhooks > Details about webhooks

Tallyfy webhooks send JSON data to external URLs when workflow events occur - at template level (any step completion or process launch/completion) or step level (specific task completions) - with an organization ID header for security validation.

Was this helpful?

YesNo