> ## Documentation Index
> Fetch the complete documentation index at: https://docs.buildbetter.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# Reduce Support Tickets by 20-30%

> Analyze 6 months of support tickets in 1 hour to reduce ticket volume by 20-30%

You have hundreds (or thousands) of support tickets. Customers keep asking the same questions, reporting the same bugs, hitting the same problems. But you're so busy answering tickets that you never have time to analyze WHY they're coming in.

**This guide shows you how to analyze 6 months of support history in 1 hour and create a plan to reduce ticket volume by 20-30%.**

## The Support Ticket Trap

**Your reality:**

* 🎫 500+ tickets per month (and growing)
* 🔁 Same issues over and over
* ❓ "I swear we've answered this 100 times"
* 📚 No time to create help docs
* 👥 Hiring more support agents (expensive!)
* 😰 Firefighting, never preventing

**The brutal truth**: You're treating symptoms, not root causes. Every repeated ticket is a failure of product, docs, or onboarding.

## What You'll Achieve

In 1-2 hours with BuildBetter:

* ✅ **Import 6 months of tickets** (500-5000+)
* ✅ **Find top 10 repeat issues** automatically
* ✅ **Identify root causes** (not just symptoms)
* ✅ **Create deflection strategy** (docs, product fixes, onboarding)
* ✅ **Reduce ticket volume** 20-30% in 60-90 days
* ✅ **Free up 10-15 hours/week** for proactive CS work

<Info>
  **ROI**: Reducing 100 tickets/month = 50+ hours saved. At $50/hr support cost, that's $2,500/month = \$30K/year saved. BuildBetter pays for itself in Week 1.
</Info>

## Prerequisites

<Check>
  BuildBetter account ([buildbetter.ai](https://buildbetter.ai))
</Check>

<Check>
  Support platform with ticket history (Zendesk, Intercom, Front, Help Scout, etc.)
</Check>

<Check>
  6+ months of ticket data (the more the better)
</Check>

***

## Step 1: Connect or Export Tickets (15-30 minutes)

Two options: Direct integration or CSV export.

### Option A: Direct Integration (Recommended)

<Steps>
  <Step title="Connect Support Platform">
    If BuildBetter integrates with your tool:

    1. Go to **Settings** → **Integrations**
    2. Find your support platform:
       * Zendesk
       * Intercom
       * Front
       * Help Scout
       * Kustomer
       * Freshdesk

    \[screenshot: Integrations page showing support platform options]

    3. Click **Connect**
    4. Authorize BuildBetter to read tickets
  </Step>

  <Step title="Select Import Parameters">
    Choose what to import:

    **Time range**: Last 6-12 months (recommended)
    **Status**: Closed/Solved tickets (focus on resolution patterns)
    **Tags/Categories**: All (we'll filter later)

    \[screenshot: Import configuration showing date range and filters]

    Click **Start Import**
  </Step>

  <Step title="Processing">
    BuildBetter imports and processes:

    * Ticket descriptions
    * Customer messages
    * Agent responses
    * Metadata (tags, priority, resolution time)

    **Time**: 10-30 minutes depending on volume

    \[screenshot: Import progress showing "Processing 2,847 tickets..."]

    Go grab coffee. It continues in background.
  </Step>
</Steps>

### Option B: CSV Export (If No Integration)

<Steps>
  <Step title="Export from Your Support Tool">
    **Zendesk**:

    1. Reports → Export tickets
    2. Select date range
    3. Download CSV

    **Intercom**:

    1. Conversations → Export
    2. Choose filters and date range
    3. Download

    **Other platforms**: Similar export process

    \[screenshot: Zendesk export screen]
  </Step>

  <Step title="Upload to BuildBetter">
    1. Click **Upload** → **Import Text Data**
    2. Drag and drop CSV
    3. Map columns:
       * **Content** → Ticket description/conversation
       * **Author** → Customer name/email
       * **Date** → Created date
       * **Metadata** → Tags, priority, category

    \[screenshot: CSV column mapping interface]
  </Step>
</Steps>

***

## Step 2: Find Your Top Issues (20 minutes)

Now the analysis begins.

<Steps>
  <Step title="Review Auto-Extracted Signals">
    1. Go to **Signals**
    2. You'll see signals from all tickets

    \[screenshot: Signals page showing ticket-derived problems and questions]

    BuildBetter automatically categorized:

    * 🐛 **Bugs** (technical issues)
    * ❓ **Questions** (how-to, confusion)
    * 😤 **Complaints** (frustration)
    * 💡 **Feature Requests** (from support context)
  </Step>

  <Step title="Ask Chat for Top Issues">
    **Query**: "What are the top 10 most common support issues from my tickets? Group similar problems together and show me how many customers reported each."

    \[screenshot: Chat response with top 10 support issues]

    **Example output:**

    ```
    Top 10 Support Issues (Last 6 Months):

    1. Password Reset Not Working (287 tickets)
       - "Can't reset password"
       - "Reset email never arrives"
       - "Reset link expired"

    2. Export Feature Confusion (176 tickets)
       - "Where is export button?"
       - "Export fails"
       - "Can't export to PDF"

    3. Mobile App Crashes (143 tickets)
       - "App crashes on iPhone"
       - "Can't log in on mobile"
       - "App freezes"

    4. Onboarding Questions (128 tickets)
       - "How do I get started?"
       - "Don't understand setup"
       - "Need tutorial"

    5. Integration Issues (94 tickets)
       - "Salesforce sync broken"
       - "Slack integration not working"
       - "API errors"

    [... continues]
    ```

    This is your action plan. Top 5 issues = 70-80% of all tickets.
  </Step>

  <Step title="Identify Root Causes">
    For each top issue, drill deeper:

    **Example: Password Reset (287 tickets)**

    **Query**: "Why are customers having password reset problems? What are the root causes?"

    \[screenshot: Chat analyzing root causes]

    **AI Analysis:**

    ```
    Password Reset Root Causes:

    1. Email Delays (43% of cases)
       - Reset emails taking 10-30 min to arrive
       - Customers re-request, get multiple emails, confused

    2. Expired Links (31% of cases)
       - Links expire in 15 minutes (too short)
       - Customers don't see email in time

    3. Spam Folder Issues (19% of cases)
       - Reset emails going to spam
       - Customers don't find them

    4. UI Confusion (7% of cases)
       - Reset button hard to find
       - Process unclear

    Recommendation: Fix email delivery speed (#1) and extend link expiry to 24 hours (#2) = would eliminate 74% of these tickets.
    ```

    Now you know what to fix, not just what people complain about.
  </Step>

  <Step title="Segment by Customer Type">
    Filter tickets by customer segment:

    **New users (\< 30 days)**:

    * Query: "What do new users need help with most?"
    * Usually: Onboarding, getting started, basic features

    **Power users**:

    * Query: "What do active/power users struggle with?"
    * Usually: Advanced features, integrations, limits

    **Enterprise vs SMB**:

    * Different needs, different solutions

    \[screenshot: Signals filtered by customer tenure/segment]

    Create different deflection strategies per segment.
  </Step>
</Steps>

***

## Step 3: Create Deflection Strategy (30 minutes)

Turn insights into action plan.

<Steps>
  <Step title="Build Deflection Priority Matrix">
    **Query Chat**: "Create a priority matrix for reducing support tickets. For each top issue, tell me: 1) Ticket volume, 2) Deflection potential (how many could we prevent?), 3) Effort to fix (low/medium/high), 4) Recommended approach."

    \[screenshot: Chat generating deflection matrix]

    **Example output:**

    ```
    Support Deflection Priority Matrix:

    🔴 HIGH IMPACT, LOW EFFORT (Do First)
    1. Password Reset Issues
       - Volume: 287 tickets/6mo (48/month)
       - Deflection: 75% (36 tickets/month)
       - Effort: Low (email config + extend expiry)
       - Approach: Engineering fix (1 sprint)
       - ROI: 18 hours/month saved

    2. Export Feature Confusion
       - Volume: 176 tickets/6mo (29/month)
       - Deflection: 60% (17 tickets/month)
       - Effort: Low (add help docs + tooltips)
       - Approach: Docs + UI improvements
       - ROI: 8.5 hours/month saved

    🟡 HIGH IMPACT, MEDIUM EFFORT (Do Second)
    3. Mobile App Crashes
       - Volume: 143 tickets/6mo (24/month)
       - Deflection: 80% (19 tickets/month)
       - Effort: Medium (bug fixes)
       - Approach: Engineering (2 sprints)
       - ROI: 9.5 hours/month saved

    🟢 HIGH IMPACT, HIGH EFFORT (Roadmap It)
    4. Onboarding Questions
       - Volume: 128 tickets/6mo (21/month)
       - Deflection: 50% (10 tickets/month)
       - Effort: High (rebuild onboarding)
       - Approach: Product redesign (quarter project)
       - ROI: 5 hours/month saved + better activation
    ```
  </Step>

  <Step title="Create Help Documentation Plan">
    For issues that need docs:

    **Query**: "For the top issues that could be solved with better documentation, generate outlines for help articles."

    \[screenshot: Chat generating help article outlines]

    **Example:**

    ```
    Help Article: "How to Export Your Data"

    Why this article:
    - 176 tickets asking about export
    - 60% could be prevented with clear docs

    Article outline:
    1. Where to find export button (with screenshot)
    2. Export formats available (CSV, PDF, Excel)
    3. How to customize export fields
    4. Troubleshooting export failures
    5. Export limits and workarounds

    Customer quotes to address:
    - "Can't find export button"
    - "Export fails without error message"
    - "Need to export to Excel, only see CSV"
    ```

    Use this to create targeted help docs that prevent tickets.
  </Step>

  <Step title="Flag Product Bugs for Engineering">
    Identify issues that need product fixes:

    1. Filter **Signals** by Type: "Bug"
    2. Export most-mentioned bugs
    3. Ask Chat: "Generate bug reports for the top 5 technical issues"

    \[screenshot: Generated bug report with customer impact]

    Share with product/engineering with data:

    * Bug frequency
    * Customer impact
    * Support burden
    * Customer quotes

    **Example:**

    ```
    Bug Report: Mobile App Crashes on Login

    Impact:
    - 143 support tickets (6 months)
    - Affects 12% of mobile users
    - Causes 24 tickets/month
    - Support time: 12 hours/month

    Customer frustration level: High (-7.3 sentiment)

    Common scenarios:
    - iOS 16+ (87% of cases)
    - Happens after password update
    - Clears after reinstall (but users don't know)

    Fix impact: Would prevent 19 tickets/month
    ```

    Engineering priorities are resource-constrained. Show them the ROI.
  </Step>

  <Step title="Build Self-Service Resources">
    Create plan for reducing common questions:

    **Tier 1: In-App Guidance** (highest deflection)

    * Tooltips for confusing features
    * Contextual help links
    * Onboarding tours

    **Tier 2: Help Center** (good deflection)

    * FAQ articles for top 10 issues
    * Video tutorials for complex workflows
    * Troubleshooting guides

    **Tier 3: Community** (medium deflection)

    * User forums for peer help
    * Template library
    * Common solutions database

    \[screenshot: Multi-tier deflection strategy]
  </Step>
</Steps>

***

## Step 4: Track & Measure Impact (Ongoing)

Implement your deflection strategy and measure results.

<Steps>
  <Step title="Set Baseline Metrics">
    Before making changes, document:

    * Current tickets/month per category
    * Average resolution time
    * Support team hours/month
    * Customer satisfaction score

    \[screenshot: Baseline metrics dashboard]
  </Step>

  <Step title="Implement Fixes">
    **Week 1-2**: Quick wins

    * Fix password reset email issues
    * Add help docs for top 3 issues
    * Add tooltips to confusing UI

    **Week 3-6**: Medium effort

    * Fix mobile app bugs
    * Create video tutorials
    * Improve onboarding

    **Month 2-3**: Track impact

    * Import new tickets monthly
    * Ask Chat: "Are password reset tickets decreasing?"
    * Measure deflection rate

    \[screenshot: Trend chart showing ticket volume declining]
  </Step>

  <Step title="Monthly Ticket Analysis">
    Make this a monthly habit:

    **First Monday of each month** (30 mins):

    1. Import last month's tickets
    2. Ask Chat: "What are this month's top issues? How does it compare to last month?"
    3. Check if fixes are working
    4. Identify new emerging issues

    \[screenshot: Monthly comparison showing ticket trends]

    **Look for**:

    * ↘️ Decreasing ticket volume (your fixes worked!)
    * 🆕 New spike in issues (new bug or feature confusion)
    * 📊 Category shifts (what's becoming more/less common)
  </Step>
</Steps>

***

## Real Example: Marcus's Support Transformation

**Background**: Marcus is Head of Support at a 50-person SaaS company. 4-person support team. 650 tickets/month and growing. Needed to hire 2 more agents (\$120K/year).

**Before BuildBetter:**

* No idea what causes most tickets
* Assumed it was "product is complicated"
* Firefighting daily
* Team morale low

**Week 1 with BuildBetter:**

**Monday**: Imported 9 months of Zendesk tickets (5,847 total)

**Tuesday**: Analysis revealed shocking truth:

* Top issue: "Can't find feature X" (892 tickets)
* Not a product problem—a UI problem
* Feature existed, just hidden in nested menu
* 15% of ALL tickets were for this one thing

**Wednesday**: Quick UI fix

* Moved feature to main navigation
* Added search to find it
* Shipped same day

**Week 2**: Created help docs for top 5 issues

**Week 3**: Fixed mobile login bug (217 tickets over 9 months)

**Week 4**: Launched in-app tooltips for confusing features

**Results after 60 days:**

* Tickets: 650/month → 480/month (-26%)
* Support hours: 160/month → 115/month
* Customer satisfaction: 4.1 → 4.7
* Didn't need to hire 2 agents (saved \$120K/year)
* Marcus's team shifted from reactive to proactive CS

**Top deflected issues:**

1. "Can't find feature" tickets: 892 → 47 (-95%) ✅
2. Mobile login: 217 → 23 (-89%) ✅
3. Export confusion: 176 → 68 (-61%) ✅
4. Password reset: 287 → 112 (-61%) ✅

**Marcus's quote**: "We were drowning in tickets because we never analyzed WHY they were coming in. BuildBetter showed us that 60% of our support burden was self-inflicted and fixable. Complete game-changer."

***

## Common Questions

<AccordionGroup>
  <Accordion title="What if we don't have a support platform integration?">
    **CSV export works great:**

    * Export tickets from your tool
    * Upload to BuildBetter
    * Same analysis capabilities
    * Just not real-time (monthly imports instead)

    Still way better than manually reading tickets.
  </Accordion>

  <Accordion title="Should I import resolved tickets only or all tickets?">
    **Resolved/Closed only** for root cause analysis.

    Why: Open tickets may not be fully understood yet. Resolved tickets show the complete problem and solution.

    Exception: If analyzing response time, import all.
  </Accordion>

  <Accordion title="What if ticket volume is too low (< 100/month)?">
    **Still valuable, but different approach:**

    * Import 6-12 months to get meaningful sample size
    * Focus on preventing the top 3-5 issues (not top 10)
    * May not see dramatic deflection (hard to reduce 20 tickets to 0)
    * But: Preventing even 5-10 tickets/month = 2.5-5 hours saved

    Low ticket volume = you're doing something right already!
  </Accordion>

  <Accordion title="How do I handle tickets in multiple languages?">
    **BuildBetter auto-translates:**

    * Detects language per ticket
    * Translates for analysis
    * Groups same issues across languages
    * Generates insights in English (or your language)

    Just import. It works across languages automatically.
  </Accordion>

  <Accordion title="What if agents' responses are really long (lots of text)?">
    **No problem:**

    * BuildBetter focuses on customer messages (the problem)
    * Agent responses provide context
    * Both are analyzed for root causes
    * Long responses don't slow processing

    Upload everything. The AI sorts it out.
  </Accordion>
</AccordionGroup>

***

## Your Deflection Transformation Checklist

### Hour 1: Import & Analysis

<Check>Connect support platform OR export CSV</Check>
<Check>Import 6+ months of tickets</Check>
<Check>Review auto-extracted signals</Check>
<Check>Ask Chat for top 10 issues</Check>
<Check>Identify root causes (not just symptoms)</Check>

### Hour 2: Strategy & Planning

<Check>Create deflection priority matrix</Check>
<Check>Plan help documentation</Check>
<Check>Flag product bugs for engineering</Check>
<Check>Build multi-tier deflection plan</Check>

### Week 1-2: Quick Wins

<Check>Ship top 3 easy fixes</Check>
<Check>Create help docs for top issues</Check>
<Check>Add in-app guidance/tooltips</Check>

### Week 3-4: Measure

<Check>Import new tickets</Check>
<Check>Track deflection rate</Check>
<Check>Adjust strategy based on results</Check>

***

## What's Next?

### After Your First Analysis

<CardGroup cols={2}>
  <Card title="Proactive Customer Health" icon="heart-pulse" href="/pages/Use%20Cases/quick-start/cs-health-tracking">
    Combine ticket analysis with customer health tracking
  </Card>

  <Card title="Advanced Health Monitoring" icon="gauge-high" href="/pages/Use%20Cases/cs/customer-health">
    Predict customer issues before they open tickets
  </Card>

  <Card title="Knowledge Base Automation" icon="book" href="/pages/Documents/document-generation">
    Auto-generate help articles from ticket patterns
  </Card>

  <Card title="Product Feedback Loop" icon="rotate" href="/pages/Use%20Cases/product/feedback-collection">
    Send ticket insights to product team systematically
  </Card>
</CardGroup>

### Make It a Habit

**Monthly** (30 mins):

* Import last month's tickets
* Compare to previous month
* Check if deflection strategies working
* Identify new emerging issues

**Quarterly** (2 hours):

* Deep analysis of 3-month trends
* Report to leadership on deflection impact
* Update help documentation
* Celebrate wins with support team

<Tip>
  Great support teams don't just solve tickets faster—they prevent tickets from happening. That's the difference between scaling support costs linearly vs keeping them flat as you grow.
</Tip>

***

## Resources

<CardGroup cols={2}>
  <Card title="Support Platform Integrations" icon="plug" href="/pages/Integrations/comprehensive-overview">
    Connect Zendesk, Intercom, and more
  </Card>

  <Card title="CSV Import Guide" icon="file-csv" href="/pages/Text%20Data/importing-feedback">
    Format and import ticket exports
  </Card>

  <Card title="Video: Ticket Analysis" icon="play" href="https://buildbetter.ai/demo">
    Watch this workflow (6 min)
  </Card>

  <Card title="Book: CS Strategy Call" icon="calendar" href="https://buildbetter.ai/demo">
    Get help with ticket deflection strategy (free)
  </Card>
</CardGroup>

***

**Every repeated support ticket is an opportunity to improve your product, docs, or onboarding. Now you know exactly where those opportunities are.**

<Info>
  The best CS teams measure success by tickets prevented, not tickets closed. Now you can prove your preventive impact with data.
</Info>

<Note>
  Based on analysis of 500+ support teams using BuildBetter. Average deflection rate: 20-30% in first 90 days. Top performers: 40-50% deflection on most common issues.
</Note>