Canned Responses: Examples From Real Teams, Good and Bad

Shayan, Founder24 min read

A clerk in a cap behind a wooden counter handing a slip of paper to a man in a tan coat, two men waiting behind him and walls of orange pigeonholes.

A canned response is a pre-written message that a support team or project maintainer saves and reuses for questions that come up every day. Depending on your help desk, they're called macros, saved replies, snippets, or message templates, and they cover everything from an automatic ticket receipt to the three sentences an engineer pastes when asking for a crash log.

Every support team builds a set of them for the same reason: nobody wants to type out the explanation for a Request Timeout error or a password reset fifteen times a day. The trouble starts when a busy teammate skims the first line of a detailed ticket, spots a familiar keyword, and fires off a template that doesn't actually fit.

Customers can tell right away when a template was used to avoid reading what they wrote. As one developer on Hacker News put it:

Heroku support answered my support ticket within a few hours (so good on them) with a canned response that pointed me to the article I had already referenced to them (not so good)

The difference between a helpful saved reply and an infuriating one comes down to what the message actually does. Bad templates pad out a non-answer with scripted apologies. Good ones do the work first, state what happened, and tell the person on the other end what happens next. To see what that looks like in practice, I went through the real saved replies, triage scripts, and support handbooks published by teams at Rust, GitLab, Basecamp, Help Scout, VS Code, KDE, and Node.js, and put together plain templates you can copy and adapt for your own queue.

What is a canned response?

A canned response is a reusable block of text that a person or an automation rule sends when a recurring question arrives. You can drop one into a reply with a slash command, trigger it from a keyboard shortcut, or fire it automatically when a ticket is created or labeled.

In tools like Zendesk, Intercom, and Gorgias, a macro can do more than paste text. It can also change the ticket's status, apply a tag, or assign the conversation to another team in the same click. Open-source triage guides do the manual version of the same workflow: KDE's bug triage repository pairs almost every pre-written reply with an instruction line for the reviewer right underneath, such as Then mark it as NEEDSINFO BACKTRACE, so answering the reporter and filing the ticket happen in one step.

Teams that use saved replies heavily usually design them as modular building blocks rather than full letters. Help Scout's support team leaves greetings and sign-offs out of their shared saved replies altogether. Support rep Kristi keeps her opener in a personal text-expander snippet on her computer instead:

Kristi from the Help Scout support team here!👋

Because the shared templates only contain the core answer, any teammate can drop one into the middle of a reply they're already typing, or stack two templates together to answer a two-part question without stitched-together seams. Gorgias formats its live-chat macros the same way: no greeting, no signature, just short sentences that answer the question.

Canned responses examples from real teams

Every real example below is quoted verbatim from a public support handbook, triage repository, or product guide, with the team's own placeholders left intact. Underneath each group is a plain-English template you can copy for your own team.

1. Welcoming and acknowledging a request

The trap with first-response templates is writing a message that reads like a parking ticket. Leading with a database ID and passive voice like "Your request is being reviewed by our support staff" tells the customer nothing they didn't already know.

A good acknowledgment sets a realistic timeframe and tells the person who has the ball. When a contributor opens a pull request on the Rust repository, the project's triagebot posts this comment:

Thanks for the pull request, and welcome! The Rust Project has assigned {reviewer} to review your changes, you should hear from them (or someone else) within the next two weeks.

It names the reviewer, gives a two-week window, and includes an honest "(or someone else)" in case the assigned maintainer gets busy.

For customer email, Basecamp's Chase Clemons shared the automatic receipt their support queue used on Buffer's blog:

Hi there! Thanks for your order with us! This is an automatic email just to let you know I've got your email. I'll get you an answer back shortly. Thanks! Chase Clemons Customer Support

When your team works against a specific service window, Gorgias's macro documentation shows how to make a ticket ID genuinely useful: state your reply window, such as 48 hours, and tell the customer how to escalate with their case ID if that window passes without a response.

Hi [first name],
 
I've got your message, and it's in our queue as #[ticket ID].
Someone on our team will read it and reply here within [one business
day / 4 hours].
 
If you figure it out in the meantime or want to add a screenshot,
just reply to this email.

2. Asking for more information or logs

When a bug report arrives without enough context to reproduce the problem, the trap is sending a vague request for "more details." That forces the customer to guess what you need and adds another round-trip to the ticket.

VS Code's ~info-needed reply falls into this trap. It opens with:

Thanks for creating this issue! We figured it's missing some basic information or in some other way doesn't follow our issue reporting guidelines. Please take the time to review these and update the issue.

Telling a user their report is missing "some basic information or in some other way" doesn't follow the rules leaves them hunting through documentation to figure out what they did wrong. Compare that with how LibreOffice's QA team asks for a test file, including a privacy warning most users wouldn't think of on their own:

Hello [user's name],

Thank you for reporting the bug. Please attach a sample document, as this makes it easier for us to verify the bug.

I have set the bug's status to 'NEEDINFO'. Please change it back to 'UNCONFIRMED' once the requested document is provided.

(Please note that the attachment will be public; remove any sensitive information before attaching it.

See <https://wiki.documentfoundation.org/QA/FAQ#sanitize> for help on how to do so.)

KDE's crash template is just as direct, naming the exact command-line tool to run:

If something crashed, we need a backtrace of it so we can figure out what's going on. Can you please attach a backtrace of the crash using the coredumpctl command-line program, as detailed in https://community.kde.org/Guidelines_and_HOWTOs/Debugging/How_to_create_useful_crash_reports#Retrieving_a_backtrace_using_coredumpctl?

Thanks!

Each of those works because it asks for one concrete artifact, explains how to get it, and tells the user what happens once they reply.

To track this down, I need one more piece of detail: [exact file,
console log, or screen recording you need].
 
You can grab it by [one-line instruction or link to help doc].
Before you send it over, make sure to strip out any API keys or
personal data. Once you reply with that, I'll dig back in.

3. Confirming a bug or outage

When something is broken, customers don't want a three-paragraph apology. They want to know that someone reproduced the problem, whether there's a workaround today, and when the fix will land.

LibreOffice's QA template for a confirmed bug is a single sentence above the build details:

Hello [user's name],

Thank you for reporting the bug. I can confirm that the bug is present in master.

Once a fix is merged, typescript-eslint's saved reply tells the developer which day the release goes out and how to get unblocked right away if they can't wait:

The fix has been merged to main, and will be released Monday, as per our release schedule If you need it sooner, please try the canary tag on NPM.

During a live incident, Intercom's bulk macro example skips corporate euphemisms, gives a concrete estimate because the root cause is known, and tells customers what to do if the fix doesn't stick for their account:

Sorry about this! 😬 We're currently experiencing a server outage, but if you check out our Status Page, we'll update it as soon as things are back online. We've identified the issue, so it should be within the next 20 mins. If you still have trouble logging in after we post the 'all clear', just reply here. 👍

I was able to reproduce this on our end, and I've logged it for our
engineering team.
 
Right now you can work around it by [workaround, if one exists].
We expect the fix to go out [timeframe or release], and I'll reply
here as soon as it's live.

4. Password resets, billing, and refunds

On account and billing tickets, the worst templates waste the opening sentences narrating what the customer just asked for. If the action takes ten seconds in your admin panel, do the action first and use the template to confirm that it's already done.

GitLab's support handbook shows this contrast using its own password-reset replies. First, it gives the stiff version it tells support engineers to avoid:

Thank you for contacting support. We can help you with this. It looks like you are asking for help with resetting your password…

Then it shows the version it wants them to send instead:

Ah, sorry to hear that you lost your password. I've issued a password reset and you are good to go. In the future, you can use this link: <link> Let us know if there is anything else we can help with.

The first reply only classifies the ticket. The second one has already clicked the reset button and handed the customer the self-serve link for next time.

The same principle applies when someone writes in about an unexpected renewal charge or asks to cancel. Basecamp's Chase Clemons shared this refund template on Buffer's blog:

Hi Jack! Sorry about that charge! I've cancelled your account and got that refund headed your way. You should see that refund on your statement within a few days. If you have any other questions, please reply to this email and I'll be happy to help. And have a fantastic weekend! Chase Clemons Customer Support

Gorgias's order-cancellation macro follows the same structure for ecommerce stores, confirming in the first sentence that the order is canceled and the refund is issued, and answering the inevitable follow-up question in the second sentence by noting that banks take 3 to 5 days to post the credit.

I've canceled the [plan name] subscription on [workspace] and issued
a full refund of $[amount] for the charge on [date].
 
It usually takes 3 to 5 business days to show back up on your card
statement. Your receipt is attached, and if you need anything else,
just reply here.

5. Saying no to a request

Saying no is uncomfortable, so teams often reach for "We'll pass this along to our product team" or tack a cheerful sign-off onto a blunt rejection. Both backfire.

Look at two closing macros from VS Code's repository. When an issue is outside the project's scope, the bot posts:

We closed this issue because we don't plan to address it in the foreseeable future. If you disagree and feel that this issue is crucial: we are happy to listen and to reconsider.

It follows that with links to the roadmap and issue guidelines, and signs off with "Thanks for your understanding, and happy coding!" Saying "we don't plan to address it" is much clearer than pretending the idea is on a list somewhere, and inviting the author to make their case earns the sign-off. VS Code's wont-fix variant, on the other hand, cuts out the invitation to disagree and keeps only: "We closed this issue because we don't plan to address it. Thanks for your understanding, and happy coding!" Without a reason or a way to push back, thanking the user for their understanding asks for something the reply hasn't earned.

KDE's triage guide has a decline written in a candid first-person voice for minor feature ideas that nobody on the core team is likely to build:

This is the kind of thing where there are arguments to be made one way or another, but if nobody submits a patch for it, very likely nothing will happen. Therefore we don't need to track this with a Bugzilla ticket. Feel free to submit a patch to add the feature if you can…

WooCommerce uses a softer close when an idea doesn't fit the current roadmap, telling the user that "it doesn't fit in with our current priorities for the project" and closing the issue with a votes needed label so the team can revisit it if enough users chime in later. For templates covering every product decision beyond a quick triage close, see our guides on how to respond to feature requests and feature request email templates.

We aren't planning to build this into [Product] because [one-sentence
reason: product focus, technical constraint, or current roadmap].
 
If you need to handle this today, the best workaround is [workaround
or third-party tool]. If our plans change down the road, we'll post
an update on [link to feedback board thread].

6. Handing off or sending someone to the right place

Nothing frustrates a customer faster than getting bounced to another department or an external vendor with a one-liner that says "not our problem." A good handoff explains why the other team is the right one to fix it and gives the customer everything they need for the next step.

When a Linux crash backtrace shows the bug is inside NVIDIA's proprietary driver rather than KDE, KDE's canned reply gives the diagnosis in one sentence, followed by the exact email address, forum link, and helper script to run:

The crash backtrace indicates that the problem is in the proprietary NVIDIA drivers.

Please report this issue to the NVIDIA folks, either by sending an email to linux-bugs@nvidia.com or making a post at https://forums.developer.nvidia.com/c/gpu-graphics/linux. It would be helpful to the NVIDIA developers if you could run nvidia-bug-report.sh and attach the resulting file in your report. Thanks!

The WordPress.org support forums do the same when someone asks for help with a paid plugin or theme, explaining the practical constraint instead of just quoting a rule: "Forum volunteers are also not given access to commercial products, so they would not know why your commercial theme or plugin is not working properly."

When the handoff is internal, naming the person taking over keeps the customer from feeling dropped into a queue. GitLab's handbook includes this template for emergency tickets at the end of an engineer's shift:

It seems like we've solved the root problem here, but if you need any help I'll be on-call for the next two hours. Feel free to open a new emergency ticket and I'll get back on a call with you right away. If it's after two hours, my colleague Francesca will be responding. I'll make sure that they have the background of the situation before I leave for the day.

I'm handing this thread over to [teammate name / our engineering team]
because [one-line reason, such as needing access to billing logs].
 
I've filled them in on what we've already tried so you won't have to
repeat yourself. You'll hear from [teammate name] here within
[timeframe].

7. Following up after silence and closing stale threads

When a ticket or issue sits quiet for weeks, the trap is sending an automated message that blames the customer for the silence, especially when your own team took months to reply in the first place.

KDE's follow-up template owns the delay right in the opening sentence:

Thank you for the bug report. Unfortunately we were not able to get to it yet. Can we ask you to please check if this is still an issue with Plasma XXXX (the latest released version).

Node.js keeps its stale warnings and closures strictly factual. Its warning gives the exact windows:

This {0} has been marked as stale due to 90 days of inactivity.

It will be automatically closed in 30 days if no further activity occurs. If this is still relevant, please leave a comment or update it to keep it open.

When those 30 days pass, Node.js closes the thread with a note that tells the author how to undo it and who to ask:

Closing this because it has stalled. Feel free to reopen if this issue/PR is still relevant, or to ping the collaborator who labelled it stalled if you have any questions.

And on typescript-eslint, maintainers check in on quiet threads with a saved reply that takes the guilt out of the conversation: "👋 Hey @{{ author }}! Just checking in, is this still something you have time for? No worries if not - I just don't want to leave it hanging."

Checking back in on this since we haven't heard from you in a couple
of weeks. Did [the steps above] fix the issue, or are you still
running into trouble?
 
I'll mark this resolved for now to keep your queue tidy, but you can
reply to this email any time and it will reopen the thread right
where we left off.

8. Community moderation

Forum moderators and review queues deal with the same etiquette mistakes every day. Quoting a rule number feels cold, while explaining the norm behind the rule usually gets people on your side.

AutoReviewComments, a browser script that Stack Exchange reviewers use to post feedback, corrects new users who leave "thanks!" as a separate answer by explaining how voting works on the site:

Please don't add "thanks" as answers. Invest some time in the site and you will gain sufficient privileges to upvote answers you like, which is the $SITENAME$ way of saying thank you.

KDE's triage guide includes a template for a newer problem on public trackers: people pasting raw language-model output into bug discussions.

Just so you know, copy-pasting LLM output into a conversation with another human is considered rude.

If you must use an LLM, synthesize its output into your own conclusion and then write it in your own words when communicating with other people.

The rest of KDE's note adds a fair exception for non-native speakers: writing your own thoughts in your native language and using a machine translator to turn them into English is completely welcome, as long as the words started as yours.

I've removed this post because [what happened, in plain words]. On
this forum, we ask everyone to [the norm, and the one-sentence reason
behind it]. Feel free to edit and repost with [what to change].

What it's like to receive a bad canned response

Customers rarely mind a saved reply when it answers the exact question they asked in two minutes. What drives people crazy is a reply that proves nobody read past the subject line.

One Hacker News commenter pointed out why detailed bug reports often get the worst answers: when a technical user writes three paragraphs explaining everything they already tested, a rushed support rep gets overwhelmed by the wall of text, latches onto the first familiar phrase, and pastes the basic troubleshooting template for that keyword. Another customer described getting the exact same password-recovery template twice in a row after writing in to explain that the password recovery page itself was broken. As a third commenter put it: "You know what makes support stand out, in a positive way? Actually reading my question."

Support engineers hate this just as much when an automation rule fires under their name. A GitLab support engineer opened an internal issue after an automated reply went out on a customer's ticket carrying the engineer's own signature. It recommended steps the customer had already tried in their opening message, and as the engineer wrote:

The automatic reply did not state that it was an automatic reply, and it used my signature, making it seem the reply was written by a human.

The second thing customers spot immediately is scripted empathy. In a Hacker News thread discussing a collection of customer support phrases, readers pushed back hard against the habit of opening every macro by mirroring the customer's feelings:

reflecting what I said back to me and telling me how frustrating it must be. No shit, I know that. Don't make me read that, just tell me how the problem can be solved.

Another reader in the same thread wrote: "Might be a British/American difference but I found all of these incredibly patronising and insincere." When an official Zoho account replied in a separate thread using stiff corporate phrasing, a reader downvoted it for "Sounding like a canned response." Zoho came back with an honest admission: "This was definitely not a canned response, but we can understand why it was seen that way. Tone is a really tricky thing through text, and we didn't mean to sound like a robot." Even a hand-typed reply reads like a macro when you lean on call-center cliches.

Stack Overflow watched this play out across millions of posts. Reviewers in its queues pick comments from a fixed menu, and new users regularly took those formal messages personally, sometimes assuming two reviewers who left identical comments were colluding against them. In 2015, Stack Exchange changed review-queue comments so every one includes a link to the review task, letting the author see that it came from a standard process. freeCodeCamp does the same in text by starting three of its closing templates with "This is a standard message notifying you that..."

How to rewrite a robotic canned response

When you audit your own templates, the easiest wins come from cutting bureaucratic phrasing and telling the reader what they can actually do next. The rule for every rewrite below is that you can't invent information the system doesn't have: promising a two-hour reply in an automated trigger when your team is asleep is worse than a dry receipt.

Take the workflow the TypeScript repository uses to close labeled issues after a quiet period:

This issue has been marked as "$1" and has seen no recent activity. It has been automatically closed for house-keeping purposes.

Here $1 is the label on the issue, such as Working as Intended. Telling someone their report was closed "for house-keeping purposes" frames their work as clutter, and nothing in the message explains what to do if the bug is still happening. Keeping the exact same facts:

This issue was labeled "$1" and hasn't had any recent activity, so
we've closed it automatically. If something has changed or we missed
context, leave a comment and ask for it to be reopened.

Now look at Zendesk's default trigger that emails a customer when a ticket arrives:

Your request ({{ticket.id}}) has been received and is being reviewed by our support staff.

To add additional comments, reply to this email.

It puts a ticket number where a greeting belongs, writes in stiff passive voice, and claims the request "is being reviewed" two seconds after the email landed, before anyone has opened it. Because the trigger doesn't know your current queue time or who will take the ticket, the rewrite only promises what the trigger actually knows:

Hi, your message is in our queue as request #{{ticket.id}}. When a
teammate replies, it will come straight to this thread, and you can
reply to this email if you want to add anything in the meantime.

Finally, look at the default warning shipped with probot/stale, which runs on thousands of GitHub repositories:

This issue has been automatically marked as stale because it has not had recent activity. It will be closed if no further activity occurs. Thank you for your contributions.

Thanking someone for their contributions right after threatening to close their unfixed bug report sounds sarcastic, and the message leaves the author to guess how much time they have or how to stop the timer. Node.js rewrote that same bot message with two numbers and one clear instruction, while typescript-eslint went a step further and wrote a human close message that tags the author by name:

Closing this issue as it's been stale for ~6 weeks without activity. Feel free to reopen @{{ author }} if you have time - but no worries if not! If anybody wants to drive it forward, please do either post here or in a new issue with the info we asked about. Thanks! 😊

Across all three rewrites, the fix is the same: say what happened, say what happens next, tell the reader how to change the outcome, and cut the sentence that's only there to sound polite.

How support teams run a large library without losing the plot

Writing your first ten saved replies takes an afternoon. The real maintenance problem shows up two years later, when your team has 300 macros and half of them reference pricing tiers or menu labels you changed six months ago.

Help Scout's support team runs over 300 saved replies and schedules a cleanup roughly once a year. Alongside leaving out greetings and sign-offs, they keep two house rules: never make product roadmap promises inside a saved reply, and always check the conversation history so two teammates don't send the same saved reply to the same customer twice. Buffer went even further in 2016 and introduced a weekly "snippet-free day" after noticing their team was leaning so heavily on saved snippets that their answers were losing their personal touch.

Teams that publish their templates usually put a warning right above them. Fedora's stock-response wiki tells triagers: "If you can be more specific than this stock response, that would be very helpful for the reporter and also more polite." GitLab's handbook says the same above its email templates, encouraging teammates to customize every message for the person they're talking to.

Once a library grows past a couple hundred entries, finding the right template and preventing broken ones from going out becomes a daily headache. On Zendesk's community forum, one admin wrote:

My team alone has 313 active macros in use, but there's really no workflow to make sure that they are still accurate and updated.

Another Zendesk admin described agents building macros with wrong settings that stripped all tags off a ticket or switched its brand, with no easy way to locate the offending macro until it caused a problem in production. To prevent that, experienced support leads ask agents to create new templates as personal macros first, test them in real conversations, and let an admin review and promote the good ones to the shared folder. Measuring which macros actually work is just as hard: a 2017 request on Zendesk's forum asking for a built-in report showing which macros correlate with bad customer satisfaction scores gathered 127 upvotes from admins tired of hacking together tracking tags.

A few platform quirks also bite teams that don't read the fine print in their help desk docs. In Intercom, the macro search bar only matches words in the macro's title, not its body text, and changing a teammate's seat from Full to Lite permanently deletes their personal macros. In Zendesk, the {{ticket.requester.name}} placeholder pulls the customer's full name into the greeting, which reads like an awkward mail merge unless you swap in {{ticket.requester.first_name}}, and Zendesk's own docs warn that applying placeholder macros to problem and incident tickets makes it easy to populate the wrong customer values. In HubSpot, typing raw curly brackets inside a snippet instead of choosing a token from the Personalize menu breaks HubSpot's template rendering service.

Where canned responses live in each help desk

Every help desk names and gates this feature a little differently. Here is what each product calls its saved replies, the plan where they start, and how many you can store:

ProductFeature nameStarts onLimit
ZendeskMacrosSuite Team or Support Team5,000 shared macros
FreshdeskCanned responsesFreeNot stated
Help ScoutSaved repliesFree10 on Free, unlimited on paid plans
IntercomMacrosEssentialNot stated
GorgiasMacrosAll plans5,000
FrontMessage templatesAll plansNo hard limit
CrispMessage shortcutsMiniNot stated
HubSpotSnippetsAll plans3 on Free, 5,000 on paid plans
Zoho DeskSnippetsStandard200
TidioMacrosGrowthNot stated

A few small limits are worth knowing before you migrate a library. Zoho Desk snippet names cannot contain spaces. Front cannot convert a private template into a shared one directly, so you have to copy the text and recreate it in the shared folder. HubSpot caps each snippet at 2,500 characters, and its mobile keyboard only displays the first 100 snippets you own. If you're weighing these tools against each other, our help desk pricing comparison breaks down what those plans actually cost.

When not to send a canned response

A support lead on Hacker News summed up the healthiest way to think about templates:

I'm all in favor of reusing my own replies to customers as long as I customize them. … save the typing, but not the thinking.

Another support engineer in the same thread agreed, noting that nobody should have to type the explanation for a timeout error fifteen times a day, as long as they tailor the reply to the ticket in front of them. Even so, there are five situations where you should skip the template picker and write the reply by hand:

  1. The customer already tried the steps in your template. Every angry story about password-reset and troubleshooting macros starts with a user explaining what didn't work and getting those exact instructions pasted back at them. Read to the bottom of the ticket before reaching for a shortcut.
  2. None of your templates actually fit. On Stack Exchange's meta forum, users complained about reviewers who "choose the closest canned comment they can find, even though none of the canned comments is a good choice." Sending a near-miss template creates more confusion than a two-sentence reply written from scratch.
  3. A teammate already sent that template earlier in the thread. If someone on the morning shift sent the standard troubleshooting guide and the customer wrote back to say they're still stuck, sending the same block of text a second time tells them nobody is reading the thread.
  4. The conversation touches legal terms or regulations. WordPress.org's support handbook puts a strict note beside its account-deletion reply: "Please do not mention any laws or legalities, regardless of country, please leave that to legal professionals." Escalate legal threads to the person on your team qualified to answer them.
  5. The template is a dead end with no next step. Customers hate getting a generic "we're looking into it" followed by weeks of silence. When handing a conversation to another team, follow Intercom's escalation rule: summarize the conversation so far, list the steps already taken, and state what happens next.

Letting your docs answer the repeat questions

GitLab's support handbook makes a point that every support team eventually discovers on its own:

If you find yourself wanting to use canned responses, or are saying the same things over and over, it's probably an opportunity to improve our process.

When the same question lands in your inbox twenty times a week, maintaining a folder of 300 macros is a band-aid for a documentation or product gap. As one SaaS founder put it on Hacker News, the real goal is fixing the product or improving the docs as common questions emerge so customers don't have to wait on a human pasting a snippet.

Juno answers the repeat questions from your docs.

Juno, the support agent in UserJot's shared inbox, answers from your docs and the sites you point her at, searches your feedback board, and hands the thread to your team when she is not sure. Conversations is in beta and free on every plan.

Try UserJot free

UserJot doesn't have a saved replies or macros feature, and that's deliberate. Instead of giving your team hundreds of snippets to tag, search, and clean up every year, our live chat and shared inbox uses Juno, our support agent, to answer repeat questions directly from your help docs and the websites you point her at. Conversations is currently in beta, opt-in, and free on every plan while in beta.

When a customer asks for a feature in chat, Juno searches your public feedback board, shows them any matching request, and once they confirm, adds their vote or files a new request for them. Later, when you change that request's status, UserJot automatically emails everyone who posted, voted, or commented. When Juno isn't sure of an answer or a customer asks for a person, she hands the thread straight to your team so you can write a real human reply with the full conversation in front of you. See our shared inbox guide for how we triage handed-off threads, and teaching Juno for how updating a doc closes a knowledge gap for good.

The UserJot inbox: a customer asks about a mobile app, and Juno finds the request on the board, adds the vote, and resolves the conversation.

Frequently asked questions

What is a canned response?

A canned response is a pre-written message saved in a help desk or text expander so support reps and automated rules can reuse it for common questions. Depending on the software you use, the same feature is called macros, saved replies, snippets, or message templates.

What is the difference between a canned response and a macro?

A canned response is just the saved text that gets inserted into a reply. A macro, in tools like Zendesk, Gorgias, and Intercom, can insert text and run ticket actions at the same time, such as changing the ticket status, adding tags, or reassigning the conversation to another department.

Can customers tell when you use a canned response?

Customers rarely notice or care when a saved reply directly answers their question in a minute. They notice immediately when the reply repeats troubleshooting steps they already said they tried, links to an article they already cited in their message, or opens with stiff call-center apologies.

How many canned responses should a support team have?

Only as many as your team can audit and keep accurate when your product changes. Help Scout's support team maintains around 300 saved replies and runs a full cleanup once a year, whereas Zendesk admins with over 300 unorganized macros often struggle to find broken templates before customers see them.

Should a canned response include a greeting and sign-off?

For shared team libraries, leaving out the greeting and sign-off works best. Both Help Scout and Gorgias strip greetings and signatures from their shared templates so agents can drop a snippet into the middle of a personalized reply or combine two snippets in one message without awkward seams.

Should an automated reply say that it is automated?

Yes, if a message is sent automatically before a human has read the ticket, say so plainly. Basecamp's auto-receipt states "This is an automatic email just to let you know I've got your email," and Stack Exchange links automated review comments to the review queue so users know a bot posted them.

How do you make canned responses sound less robotic?

Do the action the customer asked for before you reply, state what you did in the first sentence, and cut filler like "We understand how frustrating this must be." Always read the customer's full message before inserting a template, and tweak the opening or closing line so it fits the specific conversation.