Mike HeapMike is an experienced Product Manager who focuses on all the “non-development” areas of My AskAI, from finance and customer success to product design, copywriting, testing and more.
Table of Contents
- Why does "just add a chatbot" stall at 30%?
- The Three Tiers of Ticket Automation
- Tier 1: Knowledge tickets (the AI needs only knowledge)
- Tier 2: Data tickets (the AI needs the customer's own data)
- Tier 3: Action tickets (the AI needs to do something)
- What automating each tier looks like in real rollouts
- Tier 1 in the wild: Zinc, 68% of queries the same day
- Tier 2 in the wild: Edel Optics and YouGarden, the data jump
- Tier 3 in the wild: the action pattern
- How to start automating your customer service this week
- When automating customer service is the wrong call
- The takeaway
- FAQs
Created time
Jun 2, 2026 10:37 AM
Title length (<60)
Author
Ecomm?
Tags
Image
Publish date
Jun 2, 2026
Slug
how-to-automate-customer-service
Featured
Type
Article
Ready to Publish
Ready to Publish
If your plan to automate customer service is a list of ten things to automate, you've got it backwards. The order is the whole game: knowledge, then data, then action.
Every guide hands you the same flat checklist (I've read most of them). Add a chatbot, add a help center, route the tickets, drop in some canned replies. Zendesk's own guide lists seven tool types and stops there; IBM and Salesforce do the same thing in different words.
So teams read one of these, switch everything on at once, and deflect about a third of their tickets (sound familiar?). Then they stall, wondering why the number won't move.
None of those lists tells you the real shape of the problem. The tickets you can automate split into three groups, depending on what the AI needs to resolve them: just your knowledge, the customer's own data, or the ability to go and do something in another system.
You automate them in that order. The teams I've watched cross 70% or 80% didn't automate more ticket types than everyone else; they climbed the three tiers in sequence, and most teams never get off the first one.
I'm Mike, co-founder of My AskAI. We run AI customer service for 200+ ecommerce and SaaS businesses inside their existing helpdesks (Zendesk, Intercom, Freshdesk, Gorgias and HubSpot), and our agents have resolved over 1,000,000 tickets, at a rolling resolution rate north of 72% across the whole base.
This playbook is the pattern we see over and over: where automation stalls, why, and the exact order that gets it unstuck. Day one is the worst your AI will ever be, but only if you climb.
Why does "just add a chatbot" stall at 30%?
TL;DR: A knowledge-only bot only resolves tickets whose answer is already written down, which is about a third of your queue. The rest need the customer's data or an action, and a flat checklist never tells you that.
The standard advice isn't wrong, and I'd never tell you to skip the chatbot or the help center. It's incomplete in one specific, expensive way.
A knowledge-only bot can resolve any ticket whose answer is already written down somewhere. That's your how-to questions, your returns policy, your shipping times. It's real, and it's worth having.
But it's about a third of a typical support queue (a third, on a good day). The moment the bot meets a question it can't answer from an article, it gives up and routes to a human.
The problem is that the other two-thirds of your volume isn't knowledge questions. "Where's my order?" isn't in your help center; that answer lives in your order system. "Can I get a refund on order 4471?" isn't an article either; resolving it means taking an action in your backend.
A chatbot pointed only at your docs physically cannot resolve those tickets, and I watch teams blame the model for it. So deflection plateaus, and the team concludes "AI doesn't work for our kind of tickets." It works fine. We see it constantly: the AI just never had what it needed.
When I look at a team stuck around 30% and frustrated, it's almost always one of three things, and none of them are the model's fault.
First, they've buried the AI under so many escalation, triage and routing rules that it never gets a chance to attempt the other 70% (every slightly-unusual ticket is pre-routed to a human before the AI sees it). Second, they have a complex knowledge setup that hasn't been shown any love in a few years, so the AI is grounding its answers in stale or contradictory docs (garbage in, garbage out). Third, and this is the big one, the bulk of their questions are about order-specific or personalized data, and the AI simply isn't connected to it.
You can see the customer's-eye view of automation done badly in the search data. (Fun fact: right next to "how to automate customer service," people are typing "how to bypass automated customer service.") That's the failure mode: when automation is a wall instead of a resolver, customers learn to route around it.
The community threads on this are full of people who've been on both sides of it ("how do you automate customer service?", "what I did to automate 90% of my e-com customer service"). The fix has nothing to do with adding more ticket types. Resolution capability comes in tiers, and you have to climb them.
The Three Tiers of Ticket Automation
TL;DR: Every ticket needs one of three things to resolve it: Knowledge, the customer's Data, or an Action. Automate them in that order, because connecting Data (Tier 2) is where resolution jumps most.
So here's the framework we use, and it's deliberately simple. For any ticket, ask one question: what does the AI need to resolve this? There are only three answers.
It needs Knowledge (the answer is written down somewhere). It needs the customer's own Data (their order, their account). Or it needs to take an Action (do something in another system).
That's the whole model: three tiers, climbed in order, because each one costs a little more to set up but unlocks higher-value, higher-volume tickets.
Tier | What the AI needs | Example ticket types | Setup effort | What it unlocks |
1. Knowledge | Documented answers (help center, docs, website) | How-to questions, policy/FAQ, documented troubleshooting | Minutes to hours, no code | ~25-35% of volume |
2. Data | The customer's own record, via an API | Order status (WISMO), account/subscription, billing status | ~1-3 hrs of dev, once | The biggest single jump, often to 70%+ |
3. Action | To do something in another system | Returns, refunds/cancellations, sub changes, address edits | Per-workflow, with guardrails | The high-value tail; replaces manual agent work |
The single most important thing on that table is the middle row. Tier 2, connecting the customer's data, is where the biggest jump in resolution happens, and it's the rung the flat lists never even mention. Most teams stall because they never leave Tier 1.
Tier 1: Knowledge tickets (the AI needs only knowledge)
These resolve from content you already have: your help center, your website, your PDFs and SOPs, plus connected knowledge sources like Google Drive, Notion, Confluence, SharePoint, Dropbox, Salesforce and Shopify. If you've no docs at all, training on your historic tickets (the last 5,000 by default) can bootstrap a starting knowledge base.
This tier is the fastest to stand up, and the boring-but-effective place to start. Connect your sources and you're live in minutes to hours, no code.
The top ticket types here are the ones everyone starts with, and rightly so:
- "How do I…?" product and how-to questions: feature usage, setup, configuration.
- Policy and FAQ questions: returns policy, shipping times, opening hours, "do you ship to my country?"
- Troubleshooting with a documented fix: known issues where the answer already lives in a guide.
This is the rung every vendor guide stops at, and it has a hard ceiling. Tier 1 is only ever as good as your docs, so if they're stale, ambiguous or missing, this is where you fix that before doing anything else.
Tier 2: Data tickets (the AI needs the customer's own data)
This is the unlock. These tickets need read access to the individual customer's record (their order, their account, their subscription), which you give the AI through a User Data API connection (for Shopify stores it's pre-built; for everything else it's a single read-only endpoint).
Once the AI can look up live data, "where's my order?" stops being a handover and starts being a resolution.
The top ticket types:
- WISMO, "where is my order?": order and tracking status. For most ecommerce teams this is the single biggest volume driver.
- Account and subscription status: what plan am I on, when does it renew, how many seats, how much have I used.
- Billing and payment status: "did my payment go through?", invoice and receipt lookups.
Here's the number that makes the case. Edel Optics, a European eyewear retailer, was sitting at 20-30% resolution on a knowledge-only setup.
The day they connected a User Data API surfacing order, delivery, return and tracking info, resolution jumped to around 79%: roughly 50 points, effectively overnight. Edel Optics' full story walks through it.
Nothing about the model changed (and that's the whole point). The AI just finally had what it needed to answer the questions people were actually asking.
And this is exactly where teams get stuck. The questions are about backend data, and the response is "we don't have the development resource for that." In my experience that's almost never true.
It's usually only a couple of hours' work for a developer, and it's something you do once and benefit from forever. There are rarely more leverageable opportunities for your AI agent than adding one read-only API. It can even be as simple as pointing Claude or ChatGPT at your codebase and asking it to build the endpoint, so I'd argue there's genuinely no excuse for leaving it in the dev backlog any more.
Tier 3: Action tickets (the AI needs to do something)
The top tier is where the AI stops answering and starts acting. These tickets need it to do something in another system, and that's handled through Tasks: natural-language, multi-step procedures that call your APIs, ask the customer the right questions, and confirm before acting. (We price these per step, at $0.02 a step, precisely because the agent is doing a job a person would otherwise have to do.)
The top ticket types:
- Returns and exchanges: start the return, generate the label.
- Refunds and cancellations: process them within policy, with guardrails.
- Subscription changes: upgrade, downgrade, pause.
- Order and account edits: change an address, modify an order, update details.
One warning, because it's the most common Tier-3 mistake I see: you don't need a Task for everything that takes more than one reply. The test is simple: does resolving this require calling another system or doing something? If the answer is no, it's still a knowledge or data question rather than an action.
Most teams need somewhere between two and ten Tasks total, the highest-frequency, lowest-resolution ticket types where a workflow is genuinely worth building. Build those, set your handover guardrails (value limits, low-confidence escalation), and stop there.
That guardrail point matters more than it sounds. A resolution number is only honest if reaching a human is easy: automation done right routes the things it shouldn't touch straight to a person, instead of forcing a "resolution" the customer didn't get.
What automating each tier looks like in real rollouts
TL;DR: Zinc hit 68% resolution on Tier 1 (knowledge) the day they went live. Edel Optics jumped from 25% to 79% on Tier 2 (data), and refunds and returns are the Tier 3 (action) frontier teams move to next.
The framework isn't theory. Here's one rollout per tier, with the numbers (and plenty more in our customer case studies).
Tier 1 in the wild: Zinc, 68% of queries the same day
Zinc, an employment background-checking platform, spent twelve months documenting their processes before they ever switched on AI, which is exactly why Tier 1 paid off immediately for them.
They went live in minutes and resolved 68% of all queries from day one, got their response time under 60 seconds (a goal they'd chased for six months), and held a 97% CSAT score. The full Zinc case study has the detail. Good docs are what make Tier 1 land this hard.
"The speed of implementation was unreal, we got it live in minutes and the impact was immediate. We forecasted a slow impact, over time, but it was literally overnight." Sam, Zinc.
Tier 2 in the wild: Edel Optics and YouGarden, the data jump
I've already told you Edel Optics' number: 25% to roughly 79% the day they connected order data, now running at 92% CSAT across 4,067 tickets and saving around 150 hours a month.
YouGarden, a UK online garden center, is the same story at higher volume. They worked with their site builder to expose recent orders, tracking and delivery info through a User Data API, and now resolve around 66% of tickets (peaking at 82%): about 7,800 tickets a month, roughly 965 hours saved, the equivalent of six full-time agents.
YouGarden's story covers the build, and both jumps came from data rather than a cleverer model.
"What impressed us most was how accurately the AI reflects our tone, policies, and product knowledge. The responses feel genuinely helpful rather than generic, which is critical in a sector like horticulture where advice really matters." Mamunur Rahman, Head of Customer Service, YouGarden.
Tier 3 in the wild: the action pattern
Tier 3 is where I see teams head once the first two are working. RecruitCRM uses guidance to handle and hand over upgrade and cancellation tickets and plan changes, running at 68% resolution and saving 62 hours a month, per their case study.
Swytch, an e-bike kit maker already deflecting 81% of tickets across more than 4,050 conversations a month, is extending into automating address changes, refunds and order modifications via backend integrations, as Swytch's story describes. Kriptomat, at 62% resolution, is building Tasks for ID verification, per Kriptomat's story. In every case I've seen, the actions came last, deployed selectively on the few workflows that mattered.
How to start automating your customer service this week
TL;DR: Tag your last 100 tickets into the three tiers, switch on Tier 1 now, and book the one data API that resolves the most volume. That API is the highest-ROI move you can make.
You don't need a project plan. You need to tier your tickets and start climbing. Here's the order I'd give any team.
- Tier your last 100 tickets. Tag each one Knowledge, Data or Action. It's about an hour or two of work, and it tells you two things immediately: your real Tier-1 ceiling, and where your actual volume sits. (Most teams are surprised how much of it is Data.)
- Switch on Tier 1 now. Connect your help center and website as knowledge sources, and you can be live in minutes to hours. Then watch which tickets still escape to a human: that's your Tier-2 and Tier-3 shortlist, written for you.
- Book the one Tier-2 API that resolves the most tickets. Usually order or account lookup. It's roughly one to three hours of dev work, done once, and it's the highest-ROI move you will make, because it's what moved Edel Optics fifty points. If your dev team is buried, point Claude or ChatGPT at your codebase and have it scaffold the read-only endpoint. The dev-bottleneck excuse doesn't survive 2026.
- Build two or three Tier-3 Tasks to begin with. The highest-frequency, lowest-resolution actions: returns, refunds, address changes. Set your handover guardrails first, then build.
- Put 30 minutes a week in the calendar. Review what the AI still isn't resolving, fix the gap, add the next Task. "Day one is the worst it'll ever be" is only true if someone reviews weekly, and after the first month that's genuinely about half an hour (up to an hour if you run separate QA).
When automating customer service is the wrong call
TL;DR: Skip automation, or stay on Tier 1 only, if your docs don't exist, the tickets are genuinely bespoke, or you need HIPAA, ISO 27001 or PCI compliance your vendor doesn't carry.
A framework that only argues one side isn't worth much, so I'll be straight about where this one doesn't apply.
If nothing is documented, you've nothing to climb from. The AI learns from what you've written down, so if that doesn't exist, fix it first (training on historic tickets gives you a starting point, but it isn't magic).
Some tickets shouldn't be automated at all, and I wouldn't try. Genuinely bespoke cases, complaints, anything that needs real empathy should route to a human fast, instead of being forced through a workflow. Good automation includes a frictionless escalation path; the whole point of clearing the repetitive tiers is that your people get time back for exactly these tickets.
There are also compliance ceilings. If you're handling regulated data and need HIPAA, ISO 27001 or PCI-DSS, check your vendor actually certifies it before automating those workflows. We're SOC 2 Type II and GDPR compliant, and deliberately honest that we are not HIPAA, ISO or PCI certified, so if that's a hard requirement for you, we're not your fit, and you should know that up front.
And if you're already at 80% with excellent docs and connected data (and a few of our customers genuinely are), there's a limit to how much higher it goes. Diminishing returns are real, and the smart move is to bank the win. For a tiny team with great docs and low volume, a simple Tier-1 knowledge bot might be the whole answer, and that's fine too.
The takeaway
TL;DR: Automating customer service means climbing three tiers in order: Knowledge, then Data, then Action. The order matters far more than the length of your list.
Automating customer service isn't really a checklist of ten things at all. Think of it as three tiers you climb in order: Knowledge, then Data, then Action.
The reason most teams stall, I think, is that they treat all automatable tickets as one bucket, switch on a knowledge bot, and never make the jump to connecting their customer data, which is the rung that actually moves the number. Tier your tickets, stand up Tier 1 this week, and book the one Data API that resolves the most volume. That's the sequence.
It isn't a set-and-forget product, whatever anyone tells you. The teams that win review weekly and climb deliberately, and they remember that day one is the worst it'll ever be.
If you want to see what the data jump looks like in practice, Edel Optics going from 25% to 79% is the clearest example we have. Or just start tiering your tickets, and the order will tell you what to do next.
FAQs
Can you automate customer service?
Yes, and increasingly most of it. The repetitive tiers (documented answers, data lookups, and well-bounded actions) automate cleanly today; across our customer base, AI resolves north of 72% of tickets on a rolling basis. What you don't automate is the bespoke, high-empathy tail, which is what your people are for.
What is automated customer service?
It's resolving customer issues with technology rather than having a human handle each one by hand, with or without an agent in the loop. The useful way to think about it isn't a list of tools, though; it's the three tiers of what the AI needs to resolve a ticket, namely knowledge, the customer's data, or the ability to take an action.
How do you automate customer service with AI?
Connect your knowledge so the AI can answer documented questions, connect your customer data via an API so it can answer order- and account-specific ones, then add a few action workflows for the things that need doing. Climb those in order: knowledge first because it's fastest, data second because it's the biggest jump, actions last because they're the most involved.
What are some examples of automated customer service?
The everyday ones: a customer asking your return policy and getting an instant, accurate answer (knowledge), a customer asking "where's my order?" and getting live tracking back (data), and a customer starting a return and the AI processing it end to end (action). In practice that looks like Zinc resolving 68% of queries the day they went live, or Edel Optics jumping to 79% once order data was connected.
How much can AI reduce customer support costs?
The saving comes down to hours of human time: YouGarden saves around 965 hours a month (about six full-time agents), Edel Optics around 150. On the bill itself, we charge per ticket (around $0.10) rather than per resolution, which means your cost per resolved ticket actually falls as your resolution rate climbs, instead of rising with it.
What resolution rate should I expect from automated customer service?
Realistically, around 25-35% from a knowledge-only setup, and 60-80%+ once you've connected customer data and a few actions: Edel Optics runs at 79%, Swytch at 81%, YouGarden peaks at 82%. One honest note on the metric: we count a ticket as resolved when the AI handled it without escalating to a human, and we make escalating deliberately easy, so the number reflects what the AI genuinely took off your team's plate rather than tickets where the customer just gave up.
Can I automate customer service without coding?
Tier 1 and a Shopify Tier-2 setup are genuinely no-code: connect your sources and go. A custom data API or a complex action workflow needs a little development, but it's roughly one to three hours, and you can have an LLM scaffold the read-only endpoint from your codebase. For most teams, no engineer is needed to get meaningfully live.
How do I automate customer service without losing the personal touch?
Automate the repetitive tiers so your people get time back for the tickets that actually need a human, and make handover frictionless: when the AI passes a conversation over, it summarizes the context so the customer never has to repeat themselves. The personal touch dies when automation becomes a wall customers have to bypass; it survives when automation clears the routine stuff and routes the rest to a person fast.
