Here’s a practical way to set up a ticket triage tool that routes and summarizes inbound support tickets using Zendesk + Slack.

Goal

When a new Zendesk ticket arrives:

1. Capture ticket data
2. Summarize the issue
3. Classify it (billing, bug, login, feature request, etc.)
4. Route it to the right team/assignee
5. Post a Slack notification with the summary and recommended action

---

Recommended architecture

Option A: Low-code / no-code

Use:

• Zendesk Triggers + Webhooks
• Zapier / Make / Workato
• OpenAI or another LLM step
• Slack app or Slack webhook

This is fastest if you don’t want to build much.

Option B: Custom service

Use:

• Zendesk webhooks/triggers
• A small service in Node.js / Python
• LLM API for summarization/classification
• Zendesk API to update ticket fields/tags/assignee
• Slack API to post or thread notifications

This is best if you want control, reliability, and custom routing logic.

---

Setup steps

1) Define your routing rules

Before building anything, decide:

• Ticket categories: billing, technical bug, account access, feature request, cancellation, enterprise, etc.
• Priority rules: VIP customers, SLA breaches, keywords like “down”, “cannot login”, “refund”
• Assignment rules:
  • Billing → Finance queue
  • Bugs → Engineering support
  • Login/account access → Ops/support queue
  • Enterprise → Dedicated CS team

It helps to store these as:

• Zendesk custom fields
• tags
• routing maps in your app config

---

2) Prepare Zendesk

Create:

• Custom ticket fields:
  • Category
  • Priority
  • Suggested assignee/team
  • Summary
• Tags:
  • triaged
  • needs-human-review
  • billing
  • bug
  • urgent
• Groups in Zendesk for each support team

Then set up a Zendesk Trigger:

• Fire on ticket creation
• Call your webhook endpoint with:
  • ticket ID
  • subject
  • description
  • requester info
  • tags
  • priority
  • custom fields

---

3) Build the summarization/classification step

Send the ticket content to an LLM with a structured prompt.

Example output schema

Have the model return JSON like:

{
  "summary": "User cannot reset password after multiple attempts.",
  "category": "account_access",
  "priority": "high",
  "sentiment": "frustrated",
  "recommended_team": "support_ops",
  "suggested_tags": ["login_issue", "urgent"],
  "requires_human_review": true
}

Prompt guidance

Ask the model to:

• summarize in 1–2 sentences
• identify the category
• assess urgency
• extract key entities:
  • product area
  • error message
  • customer impact
  • account tier
• avoid making unsupported assumptions

---

4) Apply routing logic

Use your classification result to map tickets.

Example:

• billing → Zendesk group = Billing
• bug + high priority → Engineering support + Slack escalation
• feature_request → product feedback queue
• account_access → Support Ops

You can route by:

• tags
• custom fields
• group ID / assignee ID
• SLA escalation

Then update the Zendesk ticket via API:

• set category field
• add tags
• assign group
• optionally add an internal note with the summary

---

5) Notify Slack

Post a message to a support triage channel like #support-triage.

Include:

• Ticket ID and link
• Customer name / email
• Summary
• Category
• Priority
• Recommended team
• Suggested next action

Example Slack message

New Zendesk ticket #12345
Summary: User cannot reset password due to “invalid token” error.
Category: account_access
Priority: high
Recommended team: Support Ops
Action: Assign to on-call queue and investigate reset flow.
Open Ticket

You can also create:

• threaded updates
• emoji reactions for routing status
• buttons like “Assign to me”, “Escalate”, “Mark reviewed”

---

Suggested workflow

Inbound ticket flow

1. Ticket created in Zendesk
2. Zendesk trigger sends webhook to triage service
3. Service fetches ticket details from Zendesk API
4. Service runs summarization + classification
5. Service maps category to team
6. Service updates Zendesk ticket
7. Service posts summary to Slack
8. Optional: a human reviews edge cases

---

Best practices

Keep humans in the loop

Don’t fully automate every ticket at first. Use a confidence threshold:

• high confidence → auto-route
• low confidence → mark needs-human-review

Use structured outputs

Have the model output strict JSON so your app can parse it safely.

Don’t rely only on AI

Combine AI with rule-based logic:

• VIP customer detection
• outage keywords
• spam filtering
• known product areas

Log everything

Store:

• raw ticket text
• model output
• final routing decision
• Slack message ID
• Zendesk update response

This helps debugging and tuning.

Protect customer data

Make sure:

• data access is restricted
• sensitive fields are masked if needed
• your LLM usage complies with your privacy/security requirements

---

Minimal custom implementation outline

Components

• Webhook endpoint: receives Zendesk trigger payload
• Ticket fetcher: gets full ticket from Zendesk API
• AI classifier: returns summary + category + priority
• Router: maps category to Zendesk group/Slack channel
• Updater: writes fields/tags back to Zendesk
• Notifier: posts to Slack

Pseudocode flow

def triage_ticket(ticket_id):
    ticket = zendesk.get_ticket(ticket_id)

    result = llm.classify_and_summarize(ticket.subject, ticket.description)

    routing = route_map[result["category"]]

    zendesk.update_ticket(ticket_id, {
        "group_id": routing["zendesk_group_id"],
        "tags": ticket.tags + result["suggested_tags"] + ["triaged"],
        "custom_fields": {
            "category": result["category"],
            "summary": result["summary"],
            "priority": result["priority"]
        }
    })

    slack.post_message(
        channel=routing["slack_channel"],
        text=format_slack_message(ticket, result)
    )

---

If you want a fast MVP

Here’s the simplest path:

1. Create a Zendesk trigger on new ticket
2. Send ticket payload to a webhook
3. Use an LLM to output JSON summary/category/priority
4. Update Zendesk fields via API
5. Post summary to Slack via webhook
6. Route only 3–5 categories initially

---

Common pitfalls

• Overcomplicated taxonomy too early
• LLM hallucination if prompt/output isn’t constrained
• No fallback routing for unknown categories
• Missing Zendesk rate-limit handling
• Not testing with historical tickets
• Posting too much detail to Slack if tickets contain sensitive data

---

Example rollout plan

Week 1

• Define categories and routing map
• Create Zendesk fields/tags/groups
• Set up Slack channel and webhook

Week 2

• Build webhook receiver
• Integrate summarization/classification
• Test on historical tickets

Week 3

• Add Zendesk updates and Slack posts
• Pilot with one queue
• Human review of all AI decisions

Week 4

• Expand categories
• Add confidence thresholds
• Optimize prompt and routing rules

---

If you want, I can also give you:

1. a Zendesk trigger + webhook setup example
2. a Node.js or Python reference implementation
3. a sample LLM prompt for ticket triage
4. a Slack message template and routing schema