Turn a non-responsive chatbot into a delightful conversational experience

Learn how the 3 Strikes Rule can be an effective fallback design for chatbots.

A chatbot triggers a fallback message when it can’t intelligently respond to a message it receives from a user. If you’ve ever interacted with a chatbot on Facebook, then you know this happens a lot. Conversational designers will focus on a chatbot’s capabilities, but consumers tend to focus on what a bot can’t do and a fallback design can make or break a brand.

The potential impact of a poor fallback design is what got me interested in conversational interfaces in 2016 and I contributed some of my fallback design patterns to O'Reilly‘s Designing Bots: Creating Conversational Experiences.

Ineffective fallback designs

Let’s first look at some common conversational design pitfalls so you’ll know what to avoid.

Repetitive Fallbacks

This is the most common fallback design pattern and the one that has given chatbots a bad name.

The problem is not that the bot didn’t have a response to either message, but that each fallback message is both repetitive and negative, so it re-enforces the limitations of the bot. It’s a fast way to lose a user and negatively impact a brand.

Random Fallbacks

In this example, a bot maker will attempt to mask the chatbot’s inability to respond by randomizing the fallback message.

Randomizing fallback messages might be a more creative way to distract the user from a bot’s inability to respond, but simply alternating failure messages is a short-lived strategy that won’t help the user or the brand. Messenger users will quickly realize that random fallbacks are just a distraction and just as annoying as a repetitive fallback.

The 3 Strikes Rule ❌ ❌ ❌

The fallback pattern I like best for a Facebook bot is what I call the 3 Strikes Rule. Rather than admit failure immediately every time the bot receives a message it can’t understand, the bot will give a user 3 chances to provide input, helping the user and the brand get closer to their goal.

When a user first sends a message the bot can’t respond to, I start a “Strike count” behind the scenes and each subsequent message that triggers the fallback response will increase the strike count by one. With three strikes, I’ll give the user buttons that help them, then reset the count.

Strike 1 ❌

In my example, the user said “I’d like to order a pizza. Do you still deliver at this hour?” and the bot didn’t have a response. That’s our strike one. Rather than immediately emphasize the bot is incapable of responding, there is a chance that if the user simply re-phrases their message, the bot might understand the input and trigger the right response.

Set your strike count to one and ask them to send another message, but in a different way.

Strike 2 ❌ ❌

If users send another message that the bot can’t understand, you can increase the strike count to two, but make the message even more useful.

Let’s break the message. When the user got their strike one, the bot responded and asked them to send another message. The bot can thank them for doing what it asked them to do when they got their strike one.

Even though the bot had no response to the user’s message, the bot appears to be clever and respectful of the user’s time by acknowledging and thanking the user for following the bot’s instruction.

The second part of the message says “Let’s try one more time.”

The wording signals to the user that they should not expect the same response the next time they send a message and that any frustration will be finite. The bot is more explicit in its respect for the user’s time.

The message also provides them with some guidance.

You can now suggest ways for the user to communicate and increase the chances of getting back the right response to their input.

If your bot is focused on a particular niche, you might ask the user at this point to send you short messages specific to your niche. For example, if your bot is for a restaurant, you might respond with “Try asking questions about our menu”. You’re helping the user understand the types of messages that will produce a response rather than turning them off completely and users will appreciate the thoughtfulness.

Strike 3 ❌ ❌ ❌

With three messages received that the bot can’t respond to, you can increment the strike count to three and guide users with buttons which act as “helpers”.

You might be thinking, why wouldn’t you just give your users the buttons when they got strike one? There are a few reasons why:

1. You might want your users to click buttons to minimize errors, but statistically, less than 40% of users want to click buttons in a conversational experience, so your best approach is to first try and understand the user based their preferred method of communication.
2. You’ll never improve your conversational experience if you rely purely on buttons. The idea is to learn from the messages you receive and improve. When users send messages, you’re able to collect data that helps you make better decisions about your business and your conversational experience.
3. I like to include a button that will refocus the user on what the bot’s purpose is, and include a second button that will pause automation and connect the user to a human. If you put that button right when they get strike one, you’ll never get closer to your automation goals because you’ll just be constantly funneling users out of your automated experience into a live chat session.

A visual flow of the 3 Strikes fallback design

I used Manychat, a popular Facebook bot maker, to create this conversational design pattern. If you’re a Manychat, here is a free template you can use to save you the time of having to re-create the 3 Strikes fallback scenario I’ve described here. If you’re not a Manychat user you can replicate this in your bot platform of choice:

You might use different messaging then I shared with you in my design pattern, but the concept should be clear. With the 3 Strikes fallback design, you’re able to respond intelligently to a user even though your chatbot didn’t understand a single message the user sent!

About the author

Josh Barkin is a conversational designer and Co-founder of Janis.ai, an AI Assistant that helps business integrate Artificial Intelligence into their customer experiences and achieve their business automation goals. The best place to engage with Josh if you have any questions about this piece is through his Facebook community.