January 22, 2026

Google Sheets + Slack: ticket trends you can act on

Lisa Granqvist Partner Workflow Automation Expert

Get a free AI assessment → ⬇️ Use template

Your tickets are telling you what’s wrong. The problem is you’re hearing it too late, buried in inbox threads, exports, and “we should look into this” messages that never turn into action.

This is what ticket trends automation looks like when it’s done for outcomes, not busywork. Support managers feel it when escalations surprise them. Product folks feel it when the same bug shows up for weeks. Ops teams feel it when reporting day turns into a half-day scavenger hunt.

This workflow pulls tickets from your sources, uses AI to normalize and score them, writes clean rows into Google Sheets, then posts Slack alerts when something needs attention. You’ll see how it works, what you need, and where teams usually get tripped up.

How This Automation Works

The full n8n workflow, from trigger to final output:

n8n Workflow Template: Google Sheets + Slack: ticket trends you can act on

Click to explore

flowchart LR

    subgraph sg0["Automated Support Monitor Flow"]
        direction LR
        n0@{ icon: "mdi:play-circle", form: "rounded", label: "Automated Support Monitor Tr..", pos: "b", h: 48 }
        n1["<div style='background:#f5f5f5;padding:10px;border-radius:8px;display:inline-block;border:1px solid #e0e0e0'><img src='https://flowpast.com/wp-content/uploads/n8n-workflow-icons/webhook.dark.svg' width='40' height='40' /></div><br/>Support Ticket Webhook Trigger"]
        n2@{ icon: "mdi:cog", form: "rounded", label: "AI Support Dashboard Scraper", pos: "b", h: 48 }
        n3@{ icon: "mdi:cog", form: "rounded", label: "AI Closed Tickets Analyzer", pos: "b", h: 48 }
        n4@{ icon: "mdi:cog", form: "rounded", label: "AI Knowledge Base Analyzer", pos: "b", h: 48 }
        n5["<div style='background:#f5f5f5;padding:10px;border-radius:8px;display:inline-block;border:1px solid #e0e0e0'><img src='https://flowpast.com/wp-content/uploads/n8n-workflow-icons/code.svg' width='40' height='40' /></div><br/>Advanced Support Analytics &.."]
        n6@{ icon: "mdi:database", form: "rounded", label: "Google Sheets Support Analyt..", pos: "b", h: 48 }
        n7@{ icon: "mdi:swap-horizontal", form: "rounded", label: "Critical Escalation Filter", pos: "b", h: 48 }
        n8["<div style='background:#f5f5f5;padding:10px;border-radius:8px;display:inline-block;border:1px solid #e0e0e0'><img src='https://flowpast.com/wp-content/uploads/n8n-workflow-icons/slack.svg' width='40' height='40' /></div><br/>Slack Manager Escalation Alert"]
        n9@{ icon: "mdi:swap-horizontal", form: "rounded", label: "Analytics Summary Filter", pos: "b", h: 48 }
        n10["<div style='background:#f5f5f5;padding:10px;border-radius:8px;display:inline-block;border:1px solid #e0e0e0'><img src='https://flowpast.com/wp-content/uploads/n8n-workflow-icons/slack.svg' width='40' height='40' /></div><br/>Slack Analytics Summary Report"]
        n9 --> n10
        n3 --> n5
        n4 --> n5
        n7 --> n8
        n2 --> n5
        n1 --> n2
        n1 --> n3
        n1 --> n4
        n0 --> n2
        n0 --> n3
        n0 --> n4
        n5 --> n6
        n5 --> n7
        n5 --> n9
    end

    %% Styling
    classDef trigger fill:#e8f5e9,stroke:#388e3c,stroke-width:2px
    classDef ai fill:#e3f2fd,stroke:#1976d2,stroke-width:2px
    classDef aiModel fill:#e8eaf6,stroke:#3f51b5,stroke-width:2px
    classDef decision fill:#fff8e1,stroke:#f9a825,stroke-width:2px
    classDef database fill:#fce4ec,stroke:#c2185b,stroke-width:2px
    classDef api fill:#fff3e0,stroke:#e65100,stroke-width:2px
    classDef code fill:#f3e5f5,stroke:#7b1fa2,stroke-width:2px
    classDef disabled stroke-dasharray: 5 5,opacity: 0.5
    class n0 trigger
    class n7,n9 decision
    class n6 database
    class n1 api
    class n5 code
    classDef customIcon fill:none,stroke:none
    class n1,n5,n8,n10 customIcon

The Problem: Ticket data is everywhere (and decisions are nowhere)

Support data rarely lives in one clean system. Some tickets come through a help desk, some through a web form, others through email, and your knowledge base is a separate world entirely. Then someone is expected to “analyze trends” by skimming, exporting, cleaning columns, and guessing categories. It takes hours, it’s inconsistent, and frankly it’s easy to miss the one spike that actually matters. By the time the weekly report is done, the issue has already hit churn risk, bad reviews, or an all-hands escalation.

It adds up fast. Here’s where it breaks down in real teams:

Ticket categories drift over time because everyone labels issues a little differently.
Priority is decided in the moment, so urgent patterns look “normal” until they explode.
Reporting lives in someone’s head (or a spreadsheet tab nobody trusts).
By the time you notice an increase in a topic, you’ve already burned support hours and goodwill.

The Solution: AI-analyzed tickets to Sheets, with Slack alerts

This workflow turns scattered tickets into a single, structured dataset you can actually use. It can run on a schedule (like hourly or daily) and it can also react to new tickets via a webhook, so you’re not stuck waiting for end-of-week reporting. When it runs, it pulls in open tickets, closed tickets, and even knowledge base content, then passes the text through an AI analysis layer. That analysis standardizes categories, assigns a priority, and adds sentiment and urgency signals. Finally, it writes consistent rows into Google Sheets and posts to Slack when escalation thresholds or summary conditions are met.

The workflow starts with a schedule or an incoming ticket webhook. Scrapers extract ticket and knowledge base content, then the “Support Intelligence Engine” consolidates it into clean fields. Google Sheets becomes your dashboard, while Slack becomes your early warning system, so you can act the same day instead of “next meeting.”

What You Get: Automation vs. Results

What This Workflow Automates

Results You’ll Get

Pulling open and closed ticket content on a schedule or via webhook.
AI-based categorization, prioritization, and urgency detection from raw text.
Writing normalized ticket rows into a Google Sheets dashboard automatically.
Slack notifications for escalation spikes and summary reporting checks.

Cut weekly “trend reporting” down to about 10 minutes of review.
Fewer missed escalations because spikes trigger a Slack alert immediately.
Consistent categories across agents, which makes trend lines believable.
A living dataset you can filter by priority, sentiment, status, and owner.
Cleaner handoffs to product and ops because you have examples, not anecdotes.

Example: What This Looks Like

Say you handle about 60 tickets a day across email and your help desk. Manually, even a quick “scan + bucket into categories + note urgency” is maybe 2 minutes each, which is about 2 hours daily before anyone has a dashboard. With this workflow, you spend a few minutes setting the schedule and thresholds, then the run happens in the background and the Sheet updates automatically. Slack only pings you when there’s a real spike or high-priority cluster, so you’re not living in notifications.

What You’ll Need

n8n instance (try n8n Cloud free)
Self-hosting option if you prefer (Hostinger works well)
Google Sheets for the dashboard and storage.
Slack to send escalation and summary alerts.
ScrapeGraphAI API key (get it from your ScrapeGraphAI dashboard).

Skill level: Intermediate. You will connect accounts, paste an API key, and tweak a few prompts and thresholds.

Don’t want to set this up yourself? Talk to an automation expert (free 15-minute consultation).

How It Works

A schedule run or a new-ticket event kicks things off. The workflow can run at set intervals using the Scheduled Support Watcher, and it can also respond instantly when a new ticket hits your webhook endpoint.

Ticket and knowledge base content gets collected. Scrapers fetch open tickets, closed tickets, and relevant knowledge base content, which helps the workflow understand what’s “known,” what’s repeating, and what looks new.

AI turns messy text into consistent fields. The Support Intelligence Engine consolidates the inputs and outputs structured values like category, priority, sentiment score, urgency indicator, response time, and resolution time. This is the difference between “we think it’s getting worse” and “we saw a spike in Technical Issue, high urgency, negative sentiment.”

Your dashboard updates, then alerts fire when needed. Google Sheets gets a clean row per ticket (or per analyzed item), and Slack posts alerts when an escalation condition is met. Another check can push summary reporting to Slack, which keeps stakeholders informed without pulling a report manually.

You can easily modify alert thresholds to match your SLA and team bandwidth. See the full implementation guide below for customization options.

Step-by-Step Implementation Guide

Step 1: Configure the Trigger Type

Set up both the scheduled and webhook triggers that launch the workflow and feed parallel scraping branches.

Open Scheduled Support Watcher and set the schedule rule to run every hours using the built-in interval configuration.
Open Incoming Ticket Webhook and set HTTP Method to POST and Path to support-ticket-webhook.
Confirm the parallel flow: Scheduled Support Watcher outputs to both Open Ticket Scraper, Closed Ticket Extractor, and Knowledge Base Extractor in parallel.
Confirm the second parallel flow: Incoming Ticket Webhook outputs to both Open Ticket Scraper, Closed Ticket Extractor, and Knowledge Base Extractor in parallel.

You can disable the webhook while testing scheduled runs to isolate issues with incoming payloads.

Step 2: Connect Primary Data Sources

Configure the three scraping nodes that pull ticket and knowledge base data.

Open Open Ticket Scraper and set Website URL to https://your-support-system.com/tickets/dashboard?status=open and User Prompt to the provided JSON extraction schema.
Open Closed Ticket Extractor and set Website URL to https://your-support-system.com/tickets/closed?period=24h and User Prompt to the provided closed-ticket schema.
Open Knowledge Base Extractor and set Website URL to https://your-support-system.com/knowledge-base/search?q=frequently-asked and User Prompt to the provided knowledge base schema.
Credential Required: Connect your ScrapeGraphAI credentials in each of the three scraper nodes, because none are configured yet.

⚠️ Common Pitfall: If the scraper returns no result object, Support Intelligence Engine will output empty data, and downstream steps won’t trigger.

Step 3: Set Up Processing Logic

Configure the analytics and escalation logic that merges inputs and generates ticket-level and summary analytics.

Open Support Intelligence Engine and keep the JavaScript Code block as provided to compute SLA metrics, escalation scores, and performance summaries.
Verify that the node receives input from Open Ticket Scraper, Closed Ticket Extractor, and Knowledge Base Extractor in parallel.
Confirm that the node outputs to Update Support Sheets, Escalation Priority Check, and Performance Summary Check in parallel for downstream actions.

Step 4: Configure Output and Alert Nodes

Send processed analytics to Google Sheets and Slack, and filter escalation and summary messages with IF nodes.

Open Update Support Sheets and set Operation to appendOrUpdate, Authentication to serviceAccount, Document to [YOUR_ID], and Sheet Name to Support Data.
Credential Required: Connect your Google Sheets (Service Account) credentials in Update Support Sheets.
Open Escalation Priority Check and confirm the conditions use expressions like ={{ $json.escalation_level }}, ={{ $json.sla_breach }}, and ={{ $json.customer_tier === 'Enterprise' && $json.requires_escalation }} with Combine Operation set to any.
Open Manager Slack Alert, select Channel, and keep the message body as provided for escalation details.
Credential Required: Connect your Slack OAuth2 credentials in both Manager Slack Alert and Slack Summary Report.
Open Performance Summary Check and confirm the condition uses ={{ $json.analytics_type }} equals performance_summary.
Open Slack Summary Report, select Channel, and keep the analytics summary template text as provided.

If you want separate Slack channels for critical alerts and daily summaries, duplicate Manager Slack Alert or Slack Summary Report and adjust the channel selection.

Step 5: Test and Activate Your Workflow

Run end-to-end tests to validate data collection, analytics, and notifications before enabling the schedule.

Manually execute Scheduled Support Watcher to simulate a scheduled run and verify that all three scraper nodes trigger in parallel.
Send a POST request to the Incoming Ticket Webhook URL and confirm that the scraping nodes start in parallel.
Check Update Support Sheets for new or updated rows and verify that the Ticket ID column maps correctly.
Confirm that escalations flow through Escalation Priority Check and trigger Manager Slack Alert only when conditions match.
Verify that Performance Summary Check routes only summary data to Slack Summary Report and that Slack messages render correctly.
Once results are correct, set the workflow to Active to enable scheduled processing.

⚠️ Common Pitfall: Leaving [YOUR_ID] placeholders in Google Sheets or Slack channels will cause silent failures—replace them before activation.

🔒

Unlock Full Step-by-Step Guide

Get the complete implementation guide + downloadable template

Common Gotchas

Google Sheets permissions are picky. If rows stop writing, check the Google Sheets OAuth scopes and the spreadsheet access in your n8n credentials first.
If you’re using Wait nodes or external rendering, processing times vary. Bump up the wait duration if downstream nodes fail on empty responses.
Slack credentials can break quietly when a token is rotated. If alerts stop, confirm the Slack app still has permission to post to the target channel and reselect the channel in the node.

Frequently Asked Questions

How long does it take to set up this ticket trends automation?

About 20–25 minutes if your accounts and API keys are ready.

Do I need coding skills to automate ticket trends?

No. You’ll mostly connect credentials and adjust a few text prompts and thresholds.

Is n8n free to use for this ticket trends automation workflow?

Yes. n8n has a free self-hosted option and a free trial on n8n Cloud. Cloud plans start at $20/month for higher volume. You’ll also need to factor in ScrapeGraphAI and AI model usage (usually a few cents per run, depending on volume).

Where can I host n8n to run this automation?

Two options: n8n Cloud (managed, easiest setup) or self-hosting on a VPS. For self-hosting, Hostinger VPS is affordable and handles n8n well. Self-hosting gives you unlimited executions but requires basic server management.

Can I customize this ticket trends automation workflow for Zendesk or Freshdesk instead of scraping?

Yes, but you’ll swap the “Open Ticket Scraper” and “Closed Ticket Extractor” nodes for HTTP Request nodes that hit your help desk API. Most teams also tweak the Support Intelligence Engine code to map the help desk fields into the same Google Sheets columns. Common customizations include new category lists, different priority thresholds, and stricter rules for when Slack alerts fire.

Why is my Google Sheets connection failing in this workflow?

Usually it’s an OAuth permission issue or the spreadsheet was moved or renamed after you connected it. Re-check the Google Sheets credentials in n8n, then confirm the node is pointing at the correct spreadsheet and tab. If you’re in a Google Workspace, admin restrictions can also block access until the app is approved.

How many tickets can this ticket trends automation handle?

If you self-host n8n, there’s no execution cap; the limit is your server and the APIs you’re calling.

Is this ticket trends automation better than using Zapier or Make?

Often, yes, because this workflow isn’t just “move data from A to B.” You’re combining multiple inputs (open tickets, closed tickets, knowledge base), running logic to normalize categories and priority, then branching into escalation checks and summary reporting. n8n handles that kind of branching and data shaping cleanly, and self-hosting is a big deal if your volume grows. Zapier or Make can still be fine for a simple “new ticket → Slack message” flow. If you’re on the fence, Talk to an automation expert and you’ll get a straight recommendation.

Once this is running, your spreadsheet becomes the system of record and Slack becomes the signal, not the noise. Set it up once, then use the time you get back to fix the problems the tickets are pointing to.

Need Help Setting This Up?

Our automation experts can build and customize this workflow for your specific needs. Free 15-minute consultation—no commitment required.

Lisa Granqvist

Workflow Automation Expert

Expert in workflow automation and no-code tools.

{
"id": "",
"meta": {
"instanceId": "7529365af2f6575f98e3227cba2618e30cce88a61e2e7513fa4a1906d54f0f3d"
},
"name": "Automated Support Analytics Flow",
"tags": [],
"nodes": [
{
"id": "flowpast-topbar-6431",
"name": "Flowpast Branding",
"type": "n8n-nodes-base.stickyNote",
"position": [
0,
20
],
"parameters": {
"color": 7,
"width": 1035,
"height": 80,
"content": "## Flowpast.com | Automation Workflow Library\n**\ud83d\udcd6 Full tutorial & setup guide:** flowpast.com"
},
"typeVersion": 1
},
{
"id": "3b4ed448-99f2-41f3-b7fc-e5397dc6fac8",
"name": "Scheduled Support Watcher",
"type": "n8n-nodes-base.scheduleTrigger",
"position": [
935,
120
],
"parameters": {
"rule": {
"interval": [
{
"field": "hours"
}
]
}
},
"typeVersion": 1.2
},
{
"id": "51925e8e-1ff5-435a-8454-1511b9e94f52",
"name": "Incoming Ticket Webhook",
"type": "n8n-nodes-base.webhook",
"position": [
920,
805
],
"webhookId": "support-ticket-webhook",
"parameters": {
"path": "support-ticket-webhook",
"options": {
"noResponseBody": false
},
"httpMethod": "POST"
},
"typeVersion": 1.1
},
{
"id": "1216484d-7002-4116-a265-70ef1f20fe65",
"name": "Open Ticket Scraper",
"type": "n8n-nodes-scrapegraphai.scrapegraphAi",
"position": [
720,
215
],
"parameters": {
"userPrompt": "Extract all open support tickets from this support dashboard. Focus on ticket details, customer information, and current status. Use this schema for response: { \"request_id\": \"unique_id\", \"status\": \"completed\", \"platform\": \"Support System\", \"tickets\": [{ \"ticket_id\": \"TICKET-12345\", \"customer_name\": \"John Smith\", \"customer_email\": \"[YOUR_EMAIL]\", \"customer_tier\": \"Premium\", \"subject\": \"Login Issues\", \"description\": \"Full ticket description here\", \"category\": \"Technical\", \"priority\": \"High\", \"status\": \"Open\", \"created_date\": \"2024-01-15T10:30:00Z\", \"last_updated\": \"2024-01-15T14:20:00Z\", \"assigned_agent\": \"Agent Name\", \"tags\": [\"login\", \"authentication\"], \"customer_satisfaction_score\": null, \"response_count\": 3, \"escalated\": false, \"sla_breach\": false, \"estimated_resolution_time\": \"2024-01-16T10:30:00Z\" }] }",
"websiteUrl": "https://your-support-system.com/tickets/dashboard?status=open"
},
"typeVersion": 1
},
{
"id": "ca23168f-68a1-48a3-af78-493f32b57270",
"name": "Closed Ticket Extractor",
"type": "n8n-nodes-scrapegraphai.scrapegraphAi",
"position": [
705,
485
],
"parameters": {
"userPrompt": "Extract recently closed support tickets for performance analysis. Focus on resolution metrics and customer feedback. Use this schema: { \"request_id\": \"unique_id\", \"status\": \"completed\", \"platform\": \"Support System\", \"tickets\": [{ \"ticket_id\": \"TICKET-67890\", \"customer_name\": \"Jane Doe\", \"customer_email\": \"[YOUR_EMAIL]\", \"customer_tier\": \"Standard\", \"subject\": \"Billing Question\", \"description\": \"Full ticket description\", \"category\": \"Billing\", \"priority\": \"Medium\", \"status\": \"Closed\", \"created_date\": \"2024-01-14T09:00:00Z\", \"closed_date\": \"2024-01-15T11:30:00Z\", \"resolution_time_hours\": 26.5, \"assigned_agent\": \"Agent Name\", \"customer_satisfaction_score\": 4.5, \"resolution_summary\": \"Issue resolved by updating billing information\", \"tags\": [\"billing\", \"account\"], \"first_response_time_minutes\": 15, \"total_responses\": 5, \"escalated\": false }] }",
"websiteUrl": "https://your-support-system.com/tickets/closed?period=24h"
},
"typeVersion": 1
},
{
"id": "b0e5acf3-809a-4fcf-9600-a6174525f282",
"name": "Knowledge Base Extractor",
"type": "n8n-nodes-scrapegraphai.scrapegraphAi",
"position": [
660,
715
],
"parameters": {
"userPrompt": "Extract knowledge base articles and FAQ data to identify common issues and self-service opportunities. Use this schema: { \"request_id\": \"unique_id\", \"status\": \"completed\", \"platform\": \"Knowledge Base\", \"articles\": [{ \"article_id\": \"KB-001\", \"title\": \"How to Reset Password\", \"category\": \"Account Management\", \"views_count\": 1250, \"helpful_votes\": 89, \"not_helpful_votes\": 12, \"last_updated\": \"2024-01-10T00:00:00Z\", \"tags\": [\"password\", \"account\"], \"related_tickets_count\": 45, \"self_service_success_rate\": 0.75 }] }",
"websiteUrl": "https://your-support-system.com/knowledge-base/search?q=frequently-asked"
},
"typeVersion": 1
},
{
"id": "1e7fc7c7-1c39-4708-b46a-ad29aaf8cbac",
"name": "Support Intelligence Engine",
"type": "n8n-nodes-base.code",
"position": [
395,
420
],
"parameters": {
"jsCode": "// Advanced Customer Support Analytics & Intelligence Processing\nconst inputData = $input.all();\nconst processedTickets = [];\nconst analyticsData = [];\n\n// Configuration for support analytics and escalation rules\nconst supportConfig = {\n  slaThresholds: {\n    'Critical': { first_response_minutes: 15, resolution_hours: 4 },\n    'High': { first_response_minutes: 30, resolution_hours: 8 },\n    'Medium': { first_response_minutes: 120, resolution_hours: 24 },\n    'Low': { first_response_minutes: 480, resolution_hours: 72 }\n  },\n  customerTiers: {\n    'Enterprise': { priority_multiplier: 1.5, escalation_threshold: 0.5 },\n    'Premium': { priority_multiplier: 1.2, escalation_threshold: 0.7 },\n    'Standard': { priority_multiplier: 1.0, escalation_threshold: 1.0 },\n    'Basic': { priority_multiplier: 0.8, escalation_threshold: 1.2 }\n  },\n  categoryPatterns: {\n    'Technical': {\n      keywords: ['error', 'bug', 'not working', 'crash', 'performance', 'integration'],\n      avg_resolution_hours: 12,\n      escalation_rate: 0.15\n    },\n    'Billing': {\n      keywords: ['payment', 'invoice', 'charge', 'refund', 'subscription', 'billing'],\n      avg_resolution_hours: 6,\n      escalation_rate: 0.08\n    },\n    'Account': {\n      keywords: ['login', 'password', 'access', 'permissions', 'account', 'profile'],\n      avg_resolution_hours: 4,\n      escalation_rate: 0.05\n    },\n    'Feature Request': {\n      keywords: ['feature', 'enhancement', 'improvement', 'suggestion', 'request'],\n      avg_resolution_hours: 48,\n      escalation_rate: 0.03\n    },\n    'General Inquiry': {\n      keywords: ['question', 'information', 'how to', 'help', 'support'],\n      avg_resolution_hours: 8,\n      escalation_rate: 0.04\n    }\n  },\n  escalationTriggers: {\n    sla_breach: true,\n    high_priority_long_wait: true,\n    customer_tier_violation: true,\n    multiple_responses_no_resolution: true,\n    negative_sentiment: true\n  }\n};\n\n// Advanced ticket categorization using AI-like pattern matching\nfunction categorizeTicket(subject, description) {\n  const fullText = `${subject} ${description}`.toLowerCase();\n  let bestMatch = { category: 'General Inquiry', confidence: 0 };\n  \n  Object.entries(supportConfig.categoryPatterns).forEach(([category, config]) => {\n    let matchScore = 0;\n    config.keywords.forEach(keyword => {\n      if (fullText.includes(keyword)) {\n        matchScore += 1;\n      }\n    });\n    \n    const confidence = matchScore / config.keywords.length;\n    if (confidence > bestMatch.confidence) {\n      bestMatch = { category, confidence: Math.round(confidence * 100) };\n    }\n  });\n  \n  return bestMatch;\n}\n\n// Calculate SLA compliance and breach detection\nfunction calculateSLAMetrics(ticket) {\n  const priority = ticket.priority || 'Medium';\n  const slaConfig = supportConfig.slaThresholds[priority] || supportConfig.slaThresholds['Medium'];\n  const customerTier = supportConfig.customerTiers[ticket.customer_tier] || supportConfig.customerTiers['Standard'];\n  \n  // Adjust SLA based on customer tier\n  const adjustedSLA = {\n    first_response_minutes: Math.floor(slaConfig.first_response_minutes * customerTier.escalation_threshold),\n    resolution_hours: Math.floor(slaConfig.resolution_hours * customerTier.escalation_threshold)\n  };\n  \n  const createdTime = new Date(ticket.created_date);\n  const currentTime = new Date();\n  const lastUpdatedTime = new Date(ticket.last_updated || ticket.created_date);\n  \n  // Calculate time metrics\n  const ageInMinutes = (currentTime - createdTime) / (1000 * 60);\n  const ageInHours = ageInMinutes / 60;\n  const timeSinceLastUpdate = (currentTime - lastUpdatedTime) / (1000 * 60);\n  \n  // SLA breach detection\n  const slaBreaches = {\n    first_response_breach: ticket.response_count === 0 && ageInMinutes > adjustedSLA.first_response_minutes,\n    resolution_breach: ticket.status !== 'Closed' && ageInHours > adjustedSLA.resolution_hours,\n    update_breach: timeSinceLastUpdate > (adjustedSLA.first_response_minutes * 2)\n  };\n  \n  const overallSLABreach = Object.values(slaBreaches).some(breach => breach);\n  \n  return {\n    age_minutes: Math.round(ageInMinutes),\n    age_hours: Math.round(ageInHours * 100) / 100,\n    time_since_last_update_minutes: Math.round(timeSinceLastUpdate),\n    sla_thresholds: adjustedSLA,\n    sla_breaches: slaBreaches,\n    overall_sla_breach: overallSLABreach,\n    sla_status: overallSLABreach ? 'Breached' : 'On Track'\n  };\n}\n\n// Advanced escalation logic\nfunction calculateEscalationScore(ticket, slaMetrics, categorization) {\n  let escalationScore = 0;\n  const escalationReasons = [];\n  \n  // SLA breach escalation\n  if (slaMetrics.overall_sla_breach) {\n    escalationScore += 25;\n    escalationReasons.push('SLA Breach Detected');\n  }\n  \n  // Priority-based escalation\n  const priorityScores = { 'Critical': 20, 'High': 15, 'Medium': 5, 'Low': 0 };\n  escalationScore += priorityScores[ticket.priority] || 0;\n  \n  // Customer tier escalation\n  const tierScores = { 'Enterprise': 15, 'Premium': 10, 'Standard': 5, 'Basic': 0 };\n  escalationScore += tierScores[ticket.customer_tier] || 0;\n  \n  // Age-based escalation\n  if (slaMetrics.age_hours > 48) {\n    escalationScore += 15;\n    escalationReasons.push('Ticket Age Exceeds 48 Hours');\n  } else if (slaMetrics.age_hours > 24) {\n    escalationScore += 10;\n    escalationReasons.push('Ticket Age Exceeds 24 Hours');\n  }\n  \n  // Response pattern analysis\n  if (ticket.response_count > 5 && ticket.status !== 'Closed') {\n    escalationScore += 12;\n    escalationReasons.push('Multiple Responses Without Resolution');\n  }\n  \n  // Already escalated penalty\n  if (ticket.escalated) {\n    escalationScore += 20;\n    escalationReasons.push('Previously Escalated');\n  }\n  \n  // Technical complexity\n  if (categorization.category === 'Technical' && slaMetrics.age_hours > 8) {\n    escalationScore += 8;\n    escalationReasons.push('Complex Technical Issue');\n  }\n  \n  // Determine escalation level\n  let escalationLevel = 'None';\n  let requiresEscalation = false;\n  \n  if (escalationScore >= 50) {\n    escalationLevel = 'Critical - Immediate Manager Attention';\n    requiresEscalation = true;\n  } else if (escalationScore >= 35) {\n    escalationLevel = 'High - Team Lead Review';\n    requiresEscalation = true;\n  } else if (escalationScore >= 20) {\n    escalationLevel = 'Medium - Senior Agent Assignment';\n    requiresEscalation = true;\n  }\n  \n  return {\n    escalation_score: escalationScore,\n    escalation_level: escalationLevel,\n    requires_escalation: requiresEscalation,\n    escalation_reasons: escalationReasons\n  };\n}\n\n// Performance analytics calculation\nfunction calculatePerformanceMetrics(tickets) {\n  const totalTickets = tickets.length;\n  if (totalTickets === 0) return {};\n  \n  const closedTickets = tickets.filter(t => t.status === 'Closed');\n  const openTickets = tickets.filter(t => t.status !== 'Closed');\n  \n  // Resolution time analysis\n  const resolutionTimes = closedTickets\n    .filter(t => t.resolution_time_hours)\n    .map(t => t.resolution_time_hours);\n  \n  const avgResolutionTime = resolutionTimes.length > 0 \n    ? resolutionTimes.reduce((a, b) => a + b, 0) / resolutionTimes.length \n    : 0;\n  \n  // Customer satisfaction analysis\n  const satisfactionScores = closedTickets\n    .filter(t => t.customer_satisfaction_score)\n    .map(t => t.customer_satisfaction_score);\n  \n  const avgSatisfactionScore = satisfactionScores.length > 0\n    ? satisfactionScores.reduce((a, b) => a + b, 0) / satisfactionScores.length\n    : 0;\n  \n  // Category distribution\n  const categoryDistribution = {};\n  tickets.forEach(ticket => {\n    const category = ticket.ai_category || ticket.category || 'Unknown';\n    categoryDistribution[category] = (categoryDistribution[category] || 0) + 1;\n  });\n  \n  return {\n    total_tickets: totalTickets,\n    open_tickets: openTickets.length,\n    closed_tickets: closedTickets.length,\n    resolution_rate: Math.round((closedTickets.length / totalTickets) * 100),\n    avg_resolution_time_hours: Math.round(avgResolutionTime * 100) / 100,\n    avg_satisfaction_score: Math.round(avgSatisfactionScore * 100) / 100,\n    category_distribution: categoryDistribution,\n    escalation_rate: Math.round((tickets.filter(t => t.requires_escalation).length / totalTickets) * 100)\n  };\n}\n\n// Process each input (open tickets, closed tickets, knowledge base)\ninputData.forEach(input => {\n  if (input.json.result && input.json.result.tickets) {\n    const platform = input.json.result.platform || 'Support System';\n    \n    input.json.result.tickets.forEach(ticket => {\n      const categorization = categorizeTicket(ticket.subject, ticket.description);\n      const slaMetrics = calculateSLAMetrics(ticket);\n      const escalationAnalysis = calculateEscalationScore(ticket, slaMetrics, categorization);\n      \n      processedTickets.push({\n        json: {\n          // Ticket Identification\n          ticket_id: ticket.ticket_id,\n          platform: platform,\n          status: ticket.status,\n          created_date: ticket.created_date,\n          last_updated: ticket.last_updated,\n          closed_date: ticket.closed_date,\n          \n          // Customer Information\n          customer_name: ticket.customer_name,\n          customer_email: ticket.customer_email,\n          customer_tier: ticket.customer_tier || 'Standard',\n          \n          // Ticket Details\n          subject: ticket.subject,\n          description: ticket.description,\n          priority: ticket.priority || 'Medium',\n          original_category: ticket.category,\n          ai_category: categorization.category,\n          ai_categorization_confidence: categorization.confidence,\n          \n          // Agent and Assignment\n          assigned_agent: ticket.assigned_agent,\n          response_count: ticket.response_count || 0,\n          \n          // Time and SLA Metrics\n          age_minutes: slaMetrics.age_minutes,\n          age_hours: slaMetrics.age_hours,\n          time_since_last_update_minutes: slaMetrics.time_since_last_update_minutes,\n          sla_status: slaMetrics.sla_status,\n          sla_breach: slaMetrics.overall_sla_breach,\n          first_response_time_minutes: ticket.first_response_time_minutes,\n          resolution_time_hours: ticket.resolution_time_hours,\n          \n          // Escalation Analysis\n          escalation_score: escalationAnalysis.escalation_score,\n          escalation_level: escalationAnalysis.escalation_level,\n          requires_escalation: escalationAnalysis.requires_escalation,\n          escalation_reasons: escalationAnalysis.escalation_reasons,\n          previously_escalated: ticket.escalated || false,\n          \n          // Performance Metrics\n          customer_satisfaction_score: ticket.customer_satisfaction_score,\n          resolution_summary: ticket.resolution_summary,\n          \n          // Additional Context\n          tags: ticket.tags || [],\n          estimated_resolution_time: ticket.estimated_resolution_time,\n          \n          // Analytics Metadata\n          processed_at: new Date().toISOString(),\n          analytics_session: `analytics_${new Date().toISOString().split('T')[0].replace(/-/g, '')}`\n        }\n      });\n    });\n  }\n  \n  // Process knowledge base data\n  if (input.json.result && input.json.result.articles) {\n    const kbAnalytics = {\n      total_articles: input.json.result.articles.length,\n      high_traffic_articles: input.json.result.articles.filter(a => a.views_count > 1000).length,\n      self_service_opportunities: input.json.result.articles.filter(a => a.related_tickets_count > 20).length\n    };\n    \n    analyticsData.push({\n      json: {\n        analytics_type: 'knowledge_base',\n        data: kbAnalytics,\n        processed_at: new Date().toISOString()\n      }\n    });\n  }\n});\n\n// Generate overall performance analytics\nif (processedTickets.length > 0) {\n  const overallMetrics = calculatePerformanceMetrics(processedTickets.map(t => t.json));\n  analyticsData.push({\n    json: {\n      analytics_type: 'performance_summary',\n      data: overallMetrics,\n      processed_at: new Date().toISOString()\n    }\n  });\n}\n\n// Return both processed tickets and analytics data\nreturn [...processedTickets, ...analyticsData];"
},
"notesInFlow": true,
"typeVersion": 2
},
{
"id": "bdc4262f-f379-4b13-810b-d8f5c229656f",
"name": "Update Support Sheets",
"type": "n8n-nodes-base.googleSheets",
"position": [
165,
430
],
"parameters": {
"columns": {
"value": [],
"schema": [
{
"id": "ticket_id",
"type": "string",
"display": true,
"required": false,
"displayName": "Ticket ID",
"defaultMatch": true,
"canBeUsedToMatch": true
},
{
"id": "customer_name",
"type": "string",
"display": true,
"required": false,
"displayName": "Customer",
"defaultMatch": false,
"canBeUsedToMatch": false
},
{
"id": "customer_tier",
"type": "string",
"display": true,
"required": false,
"displayName": "Customer Tier",
"defaultMatch": false,
"canBeUsedToMatch": false
},
{
"id": "subject",
"type": "string",
"display": true,
"required": false,
"displayName": "Subject",
"defaultMatch": false,
"canBeUsedToMatch": false
},
{
"id": "priority",
"type": "string",
"display": true,
"required": false,
"displayName": "Priority",
"defaultMatch": false,
"canBeUsedToMatch": false
},
{
"id": "ai_category",
"type": "string",
"display": true,
"required": false,
"displayName": "AI Category",
"defaultMatch": false,
"canBeUsedToMatch": false
},
{
"id": "status",
"type": "string",
"display": true,
"required": false,
"displayName": "Status",
"defaultMatch": false,
"canBeUsedToMatch": false
},
{
"id": "age_hours",
"type": "number",
"display": true,
"required": false,
"displayName": "Age (Hours)",
"defaultMatch": false,
"canBeUsedToMatch": false
},
{
"id": "sla_status",
"type": "string",
"display": true,
"required": false,
"displayName": "SLA Status",
"defaultMatch": false,
"canBeUsedToMatch": false
},
{
"id": "escalation_level",
"type": "string",
"display": true,
"required": false,
"displayName": "Escalation Level",
"defaultMatch": false,
"canBeUsedToMatch": false
},
{
"id": "requires_escalation",
"type": "boolean",
"display": true,
"required": false,
"displayName": "Requires Escalation",
"defaultMatch": false,
"canBeUsedToMatch": false
},
{
"id": "assigned_agent",
"type": "string",
"display": true,
"required": false,
"displayName": "Assigned Agent",
"defaultMatch": false,
"canBeUsedToMatch": false
},
{
"id": "customer_satisfaction_score",
"type": "number",
"display": true,
"required": false,
"displayName": "CSAT Score",
"defaultMatch": false,
"canBeUsedToMatch": false
}
],
"mappingMode": "autoMapInputData",
"matchingColumns": [
"ticket_id"
]
},
"options": [],
"operation": "appendOrUpdate",
"sheetName": {
"__rl": true,
"mode": "list",
"value": "gid=0",
"cachedResultUrl": "",
"cachedResultName": "Support Data"
},
"documentId": {
"__rl": true,
"mode": "list",
"value": "[YOUR_ID]",
"cachedResultUrl": "",
"cachedResultName": "Support Analytics Dashboard"
},
"authentication": "serviceAccount"
},
"typeVersion": 4.4
},
{
"id": "8bcab229-4e1e-4733-8c15-0cad5d52790e",
"name": "Escalation Priority Check",
"type": "n8n-nodes-base.if",
"position": [
210,
250
],
"parameters": {
"options": [],
"conditions": {
"options": {
"leftValue": "",
"caseSensitive": true,
"typeValidation": "strict"
},
"conditions": [
{
"id": "critical-escalation",
"operator": {
"type": "string",
"operation": "equals"
},
"leftValue": "={{ $json.escalation_level }}",
"rightValue": "Critical - Immediate Manager Attention"
},
{
"id": "sla-breach",
"operator": {
"type": "boolean",
"operation": "true"
},
"leftValue": "={{ $json.sla_breach }}",
"rightValue": true
},
{
"id": "high-tier-customer",
"operator": {
"type": "boolean",
"operation": "true"
},
"leftValue": "={{ $json.customer_tier === 'Enterprise' && $json.requires_escalation }}",
"rightValue": true
}
],
"combineOperation": "any"
}
},
"typeVersion": 2
},
{
"id": "e89856d6-57c0-4045-8436-7ec0a0b7dcec",
"name": "Manager Slack Alert",
"type": "n8n-nodes-base.slack",
"position": [
10,
225
],
"webhookId": "ebf5c02f-bca1-48ac-9347-d42e53db23ea",
"parameters": {
"text": "\ud83d\udea8 **SUPPORT ESCALATION ALERT** \ud83d\udea8\n\n{% if $json.escalation_level contains 'Critical' %}\ud83d\udd34 **CRITICAL ESCALATION REQUIRED** \ud83d\udd34{% else %}\u26a0\ufe0f **HIGH PRIORITY TICKET** \u26a0\ufe0f{% endif %}\n\n**Ticket**: {{ $json.ticket_id }}\n**Customer**: {{ $json.customer_name }} ({{ $json.customer_tier }} Tier)\n**Subject**: {{ $json.subject }}\n\n**Priority**: {{ $json.priority }}\n**Category**: {{ $json.ai_category }} ({{ $json.ai_categorization_confidence }}% confidence)\n**Assigned Agent**: {{ $json.assigned_agent || 'Unassigned' }}\n\n**Time Metrics**:\n\u23f0 **Ticket Age**: {{ $json.age_hours }} hours\n{% if $json.sla_breach %}\ud83d\udd34 **SLA STATUS**: BREACHED{% else %}\ud83d\udfe2 **SLA STATUS**: {{ $json.sla_status }}{% endif %}\n\u23f1\ufe0f **Time Since Last Update**: {{ $json.time_since_last_update_minutes }} minutes\n\n**Escalation Analysis**:\n\ud83d\udcca **Escalation Score**: {{ $json.escalation_score }}/100\n\ud83c\udfaf **Escalation Level**: {{ $json.escalation_level }}\n\n**Why This Requires Attention**:\n{% for reason in $json.escalation_reasons %}- {{ reason }}\n{% endfor %}\n\n**Customer Context**:\n{% if $json.customer_satisfaction_score %}\u2b50 **Previous CSAT**: {{ $json.customer_satisfaction_score }}/5{% endif %}\n\ud83d\udcac **Response Count**: {{ $json.response_count }}\n{% if $json.previously_escalated %}\u26a0\ufe0f **Previously Escalated**: Yes{% endif %}\n\n**Ticket Description**:\n_{{ $json.description | truncate(200) }}_\n\n\ud83d\udd17 **Action Required**: Immediate manager review and assignment\n\n*Processed at {{ $json.processed_at | date('short') }} | Session: {{ $json.analytics_session }}*",
"select": "channel",
"channelId": {
"__rl": true,
"mode": "name",
"value": "[YOUR_ID]"
},
"otherOptions": [],
"authentication": "oAuth2"
},
"typeVersion": 2.2
},
{
"id": "4db9ad91-4584-46d5-99f2-55907fcfb5ff",
"name": "Performance Summary Check",
"type": "n8n-nodes-base.if",
"position": [
205,
665
],
"parameters": {
"options": [],
"conditions": {
"options": {
"leftValue": "",
"caseSensitive": true,
"typeValidation": "strict"
},
"conditions": [
{
"id": "analytics-data",
"operator": {
"type": "string",
"operation": "equals"
},
"leftValue": "={{ $json.analytics_type }}",
"rightValue": "performance_summary"
}
],
"combineOperation": "any"
}
},
"typeVersion": 2
},
{
"id": "f503cb4d-c6fb-4cd1-b9a8-be6c3414b773",
"name": "Slack Summary Report",
"type": "n8n-nodes-base.slack",
"position": [
0,
690
],
"webhookId": "419f9429-af3c-4e4b-989c-c66e0aa1b0a0",
"parameters": {
"text": "\ud83d\udcca **SUPPORT ANALYTICS SUMMARY** \ud83d\udcca\n\n**Overall Performance Metrics:**\n\n**Ticket Volume:**\n\ud83c\udfab **Total Tickets**: {{ $json.data.total_tickets }}\n\ud83d\udcc2 **Open Tickets**: {{ $json.data.open_tickets }}\n\u2705 **Closed Tickets**: {{ $json.data.closed_tickets }}\n\ud83d\udcc8 **Resolution Rate**: {{ $json.data.resolution_rate }}%\n\n**Performance Indicators:**\n\u23f1\ufe0f **Avg Resolution Time**: {{ $json.data.avg_resolution_time_hours }} hours\n\u2b50 **Avg Customer Satisfaction**: {{ $json.data.avg_satisfaction_score }}/5\n\ud83d\udd3a **Escalation Rate**: {{ $json.data.escalation_rate }}%\n\n**Category Breakdown:**\n{% for category, count in $json.data.category_distribution %}\ud83d\udccb **{{ category }}**: {{ count }} tickets\n{% endfor %}\n\n**Key Insights:**\n{% if $json.data.escalation_rate > 15 %}\u26a0\ufe0f High escalation rate detected - review process efficiency{% endif %}\n{% if $json.data.avg_satisfaction_score < 4.0 %}\u26a0\ufe0f Customer satisfaction below target - investigate common issues{% endif %}\n{% if $json.data.resolution_rate < 80 %}\u26a0\ufe0f Resolution rate below target - resource allocation needed{% endif %}\n\n*Generated at {{ $json.processed_at | date('short') }}*",
"select": "channel",
"channelId": {
"__rl": true,
"mode": "name",
"value": "[YOUR_ID]"
},
"otherOptions": [],
"authentication": "oAuth2"
},
"typeVersion": 2.2
}
],
"active": false,
"pinData": [],
"settings": {
"executionOrder": "v1"
},
"versionId": "",
"connections": {
"Performance Summary Check": {
"main": [
[
{
"node": "Slack Summary Report",
"type": "main",
"index": 0
}
]
]
},
"Closed Ticket Extractor": {
"main": [
[
{
"node": "Support Intelligence Engine",
"type": "main",
"index": 0
}
]
]
},
"Knowledge Base Extractor": {
"main": [
[
{
"node": "Support Intelligence Engine",
"type": "main",
"index": 0
}
]
]
},
"Escalation Priority Check": {
"main": [
[
{
"node": "Manager Slack Alert",
"type": "main",
"index": 0
}
]
]
},
"Open Ticket Scraper": {
"main": [
[
{
"node": "Support Intelligence Engine",
"type": "main",
"index": 0
}
]
]
},
"Incoming Ticket Webhook": {
"main": [
[
{
"node": "Open Ticket Scraper",
"type": "main",
"index": 0
},
{
"node": "Closed Ticket Extractor",
"type": "main",
"index": 0
},
{
"node": "Knowledge Base Extractor",
"type": "main",
"index": 0
}
]
]
},
"Scheduled Support Watcher": {
"main": [
[
{
"node": "Open Ticket Scraper",
"type": "main",
"index": 0
},
{
"node": "Closed Ticket Extractor",
"type": "main",
"index": 0
},
{
"node": "Knowledge Base Extractor",
"type": "main",
"index": 0
}
]
]
},
"Support Intelligence Engine": {
"main": [
[
{
"node": "Update Support Sheets",
"type": "main",
"index": 0
},
{
"node": "Escalation Priority Check",
"type": "main",
"index": 0
},
{
"node": "Performance Summary Check",
"type": "main",
"index": 0
}
]
]
}
}
}