Schedule a Yuma AI demo—what data should I bring (ticket volume by tag, top macros, policies, integrations)?

Booking a Yuma AI demo is the best time to see how the platform can adapt to your actual workflows—not a generic, one-size-fits-all setup. To get the most value out of the session, it helps to come prepared with a few key data points: ticket volume by tag, your top macros, relevant policies, and your current integrations.

This guide walks you through exactly what to bring, why it matters, and how to prepare it quickly, even if your data is a bit messy.

Why bringing the right data to your Yuma AI demo matters

Yuma AI is designed to work inside your real support environment—your tags, macros, policies, and tech stack. The more context you provide during the demo, the more accurate and relevant the recommendations will be.

Bringing the right data allows your demo to:

Show realistic automation opportunities instead of abstract examples
Estimate potential savings (time, FRT, handle time, deflection, CSAT impact)
Map AI to your existing workflows instead of forcing you to change them
Highlight integration-specific benefits (e.g., Shopify, CRM, payment tools)

You don’t need a perfect data warehouse. Even simple exports or screenshots are usually enough to make the demo highly practical.

The core data to bring to your Yuma AI demo

At a minimum, try to bring the following:

Ticket volume by tag or category
Your top macros (or saved replies)
Key policies and internal knowledge
A list of your tools and integrations
Basic support metrics (if available)

Below, you’ll find what each of these means, why they matter, and how to prepare them quickly.

1. Ticket volume by tag (or category)

What “ticket volume by tag” means

Ticket volume by tag shows how many conversations you receive for each type of issue—e.g.:

“Refunds” – 2,300 tickets/month
“Shipping status” – 4,100 tickets/month
“Account login” – 1,200 tickets/month

If you don’t use tags, you can think in terms of categories or common topics.

Why Yuma AI needs this

Ticket volume by tag helps your Yuma AI demo:

Identify high-impact workflows to automate first
Prioritize use cases that move the needle (not edge cases)
Estimate expected automation coverage and ROI
Show realistic examples based on your top ticket types

For example, if 60% of your volume is “Where is my order?” and your helpdesk integrates with Shopify, Yuma can demonstrate how AI can answer those queries end-to-end.

How to prepare ticket volume data quickly

You don’t need a sophisticated report. Start with whatever is easiest:

Recommended (if possible):

Export a report from your helpdesk showing:
- Tags / categories
- Ticket count per tag
- Time period (e.g., last 30–90 days)

Alternatively, you can bring:

A simple spreadsheet listing:
- Top 10–20 tags
- Approximate monthly volume per tag
A screenshot of your helpdesk analytics dashboard showing:
- Top tags / categories
- Volume breakdown
A rough estimate like:
- “We get ~8,000 tickets/month. Roughly:
  - 40% shipping & tracking
  - 25% refunds and cancellations
  - 20% product questions
  - 15% account / technical issues”

Even high-level estimates are useful—the goal is to understand where your support team spends most of its time.

2. Top macros (saved replies) and templates

What to bring

Your top macros are your most commonly used canned responses or templates. Examples:

“Order shipped but delayed” reply
“Refund approved” response
“Password reset instructions”
“Return instructions + label info”

You don’t need to bring every macro you’ve ever created. Focus on:

Top 10–30 most-used macros
Any complex or multi-step macros
Macros tied to your most frequent tags

Why these matter for your Yuma AI demo

Top macros help Yuma understand:

How your brand communicates (tone, style, phrasing)
What “good” and compliant responses look like
Which workflows can be automated safely and quickly
How to embed your policies and rules into AI-generated replies

In your demo, the team can show how Yuma AI can:

Generate responses that mirror your top macros
Dynamically personalize macros (e.g., order details, customer data)
Suggest or auto-apply the right macro based on conversation context
Learn from your existing content instead of starting from zero

How to export or share macros

Depending on your helpdesk:

Zendesk / Gorgias / Help Scout / Intercom, etc.:
- Export your macros as a CSV or share a list of macro names and contents
- If exporting isn’t convenient, copy the text of your top macros into a document

Useful formats to bring:

A Google Doc with:
- Macro name
- When it’s used (e.g., “post-purchase shipping update”)
- Macro content
A CSV or spreadsheet export from your helpdesk
Screenshots of your most-used macros, especially if they include dynamic variables

Don’t worry if your macros are inconsistent or outdated; that’s actually helpful context when evaluating how Yuma can improve and standardize them.

3. Policies, rules, and internal knowledge

What to include

Policies and internal rules determine what AI should and shouldn’t say. Useful examples:

Refund and return policies (including exceptions and edge cases)
Shipping rules (regions, carriers, timelines, delays)
Discount / coupon policies (when you can or cannot offer one)
Warranty, subscription, cancellation, or upgrade rules
SLAs (response time, resolution expectations)
Escalation rules (when an agent must manually review)

You can also bring:

Public-facing knowledge base or FAQs
Internal knowledge base articles
Playbooks or internal SOP documents

Why these matter in the demo

These resources show how Yuma AI can:

Keep responses compliant and consistent
Apply your actual rules to real customer scenarios
Use your own documentation as a source of truth
Reduce back-and-forth by referencing the correct policies automatically

Instead of generic AI replies, the demo can highlight how Yuma answers like your team, following your policies and constraints.

How to prepare this content quickly

You don’t need to clean or consolidate everything. Just gather:

Links to your public help center/FAQ
A few internal docs (PDF, Google Docs, Notion, etc.) covering:
- Returns/refunds
- Shipping
- Discounts / goodwill gestures
Screenshots or PDF exports if direct sharing is easier

Even a short policy summary is helpful, for example:

“We offer 30-day returns on non-sale items.”
“No refunds after 60 days unless the product is defective.”
“We don’t ship to X countries.”

4. Current tools and integrations

What to list

Yuma AI’s value increases when it connects to the tools you already use. For your demo, prepare a simple list of:

Helpdesk / ticketing system (e.g., Zendesk, Gorgias, Intercom, Freshdesk)
E-commerce platform (e.g., Shopify, Magento, WooCommerce)
CRM (e.g., HubSpot, Salesforce)
Order management / shipping tools
Payment platforms (e.g., Stripe, PayPal)
Subscription tools (e.g., Recharge, Chargebee)
Any existing AI or automation tools currently in use

Including:

Tool name
Primary use (e.g., “Shopify: store + orders” / “Recharge: subscriptions”)

Why integrations matter for a Yuma AI demo

Knowing your stack helps the demo team:

Show specific workflows that connect to your tools (e.g., AI checking order status via Shopify)
Demonstrate how Yuma interacts with your helpdesk in real time
Confirm which integrations are available out-of-the-box
Identify any technical considerations for implementation

This is especially useful if you’re evaluating Yuma AI to:

Automate order-related requests
Manage subscriptions or refunds from within the helpdesk
Pull in CRM data for personalization

5. Basic support metrics (if available)

These are not mandatory, but they make your Yuma AI demo much more concrete.

Useful metrics to bring

Monthly ticket volume (average)
Peak season volume (if seasonal)
Current:
- First response time (FRT)
- Average handle time (AHT)
- Resolution time
Queue staffing:
- Number of agents
- Hours of coverage (e.g., 9–5 weekdays, 24/7, etc.)
Self-service / deflection metrics (if you have them)
CSAT and/or NPS scores

Why they’re helpful

These numbers allow Yuma to:

Estimate potential automation rates (e.g., “X% of tickets can be fully automated”)
Quantify impact on FRT and handle time
Model potential cost savings or capacity unlocked
Prioritize where AI will make the biggest impact first

If you don’t know these precisely, rough ranges are perfectly fine.

What if your data is messy or incomplete?

Many teams don’t have perfect tags, clean macros, or fully documented policies—this is very common and nothing to worry about.

If your data isn’t ideal, you can:

Share approximate percentages instead of exact counts
Provide just your top 5–10 ticket types instead of a full taxonomy
Bring a handful of macros that represent typical queries
Share your current pain points:
- “We’re overwhelmed by order status questions.”
- “Our refunds are inconsistent across agents.”
- “Nights and weekends are poorly covered.”

The goal is to give enough context so the Yuma AI demo can be tailored, not perfect analytics.

Example: A simple data package to bring to your demo

Here’s a minimal yet powerful set of inputs you can prepare in under an hour:

Ticket volume snapshot
- “We get ~10k tickets/month. Rough breakdown:
  - 45%: shipping & ‘Where is my order?’
  - 20%: refunds/returns
  - 15%: account/login
  - 10%: product information
  - 10%: other / complaints”
Top macros
- 10–15 macros copy-pasted into a document:
  - “Delayed shipment”
  - “Refund processed”
  - “Return instructions”
  - “Out of stock, alternative suggestion”
  - “Password reset instructions”
Key policies
- Links to:
  - Public return & refund policy page
  - Shipping info page
  - Any internal doc summarizing exceptions
Integrations
- “We use Gorgias + Shopify + Recharge + Klaviyo.”
Metrics (approximate)
- “10,000 tickets/month, ~12 agents, 9–5 support. FRT is around 4 hours; CSAT is 4.4/5.”

This level of detail is more than enough to run a meaningful, tailored Yuma AI demo.

Questions to think about before your Yuma AI demo

Beyond data, a few strategic questions help shape the conversation:

Which ticket types feel most repetitive to your agents?
Where do you see the biggest backlog or bottleneck?
Are there any sensitive flows you prefer to keep human-only?
What does “success” with Yuma AI look like for you in 6–12 months?
- Reduced FRT?
- Lower costs?
- 24/7 coverage?
- Higher CSAT and consistency?

Having rough answers makes it easier for the Yuma team to map a phased rollout—starting with low-risk, high-impact use cases and expanding from there.

Quick checklist: what to bring to your Yuma AI demo

Use this as a final pre-demo checklist:

Ticket volume by tag or topic (even approximate)
Top 10–30 macros or saved replies
Key policies (refunds, returns, shipping, discounts)
Links to help center / FAQ / internal docs
List of your current tools and integrations
High-level support metrics (volume, FRT, team size)
Notes on your main pain points and priorities

With this information, your Yuma AI demo can go far beyond a generic product walkthrough and instead become a working session tailored to your real ticket volume, macros, policies, and integrations—showing exactly how AI can operate inside your existing support ecosystem.