How support is changing and where it is going

• What challenges do we face with support today?
  • Customer
  • Support
• What changes and how can this help?
  • Self-service becomes core
  • Chat becomes king/queen
  • Support becomes a function, not a team
  • Generative AI changes everything
  • Hyper-personalization becomes a reality
• TL;DR

“The only constant is life is change”

When we look at the amount of changes in the past few years, heck, even the past few months, things are constantly changing. So what makes us think what we were doing years ago will work today? Simple answer, in most cases it won’t, at least not efficiently, hence the need to identify and evolve.

An example of this is how the introduction of the internet changed how we find and discover knowledge. It led to the creation of instant messaging and social media, which impacted how we can engage with customers/prospects. This has also changed the expectations and needs of these individuals.

The recent proliferation of generative AI (genAI/LLMs) brings a new wave that will drastically change both the type and methods of support we can provide. Note that while this post focuses on the application of support here, the availability of genAI will impact all functions of the business.

What challenges do we face with support today?

Neither customers nor support is happy with the current state of support.

Customer

• Slow response times and iterative back and forth.
• Getting tossed around between agents.
• Lack of self-service resolution.
• Legacy communication mechanisms (phone, email).
• Lack of personalization and knowledge of who, what, where leading to the repetitive and frustrating knolwedge gathering questions.
• Lack of visibility on progress once filed (goes into a black hole), may require action to request updates.
• Lack of enablement and visibility on upcoming and recent changes.

Support

• Lack of knowledge and sharing.
• Crude skill-based routing.
• Repetitive actions.
• Lack of status/information flow between functions.
• Lots of manual activity.
• Poor deflection or self-service.

What changes and how can this help?

At a high level, the following changes are already apparent or will be:

• Bringing support to where your customers are.
• Self-service becomes core.
• The use of chat/social overtakes email/voice.
• Generative AI changes all.
• Hyper-personalization becomes reality.
• Support becomes a function, not a team.

We will dive into each one of these further below.

Self-service becomes core

With the proliferation of e-commerce and rapid delivery services like Amazon Prime, Doordash, and others, we are becoming extremely impatient. If people want things and they want them now, how does this impact your business and support? Well, they want to get support or a solution and they want it on their schedule, and quickly.

Now, obviously they can’t have everything; however, the theme is what is important: self-service becoming core to the experience.

So what do you need to do?

It is important to provide any necessary content to them which may allow them to resolve their own issues. Things like self-service guides, tutorials, knowledge base articles (KBs), docs, API documentation are all very important.

With this the user can support themselves in some scenarios, providing a better experience for them, and less work for your support team.

What do you need to do?

• Ensure all available resources are publicly accessible.
• Ensure everything is indexed and findable via search.
• Place links in prominent places allowing people to access related information.
• Ensure AI-based tools have access to all of this context.

Chat becomes king/queen

When was the last time you called a company for support? If recently, was this because you were forced to or wanted to?

Personally, I have seen a drastic shift in the way I want to engage with support moving to a more asynchronous “chat-like” model via widgets, text, WhatsApp, or social media. It gets rid of the horrible hold music, provides a more real-time experience, and allows me to multi-task.

Do you still need to support email? What about portal-based ticket creation? Absolutely. What about voice? I think that is up for debate and will diminish over time. This alludes to how things are changing and as younger generations become more prominent consumers (they may be already), this shift will be even more drastic.

I believe chat will be the primary method of communication in the next few years. Don’t fear it, embrace it and help yourself and customers alike.

What do you need to do?

• Ensure you have chat support on all web pages/apps.
• This extends to things like text messaging and chat tools like WhatsApp.
• Add support for social support interactions.

Support becomes a function, not a team

When thinking about traditional support, we are quick to jump to dedicated teams and different tiers of excellence. This was done as part of the specialization of skills, the opportunity cost of time and the need for cost effectiveness. These assumptions are rapidly changing.

For example, let’s take the legacy flow of a customer filing a request:

1. The customer files a feature request.
2. The support engineer engages and may get some additional context.
3. As this is an item they cannot solve, they “escalate” it to another system for PM to take a look.
4. PM may want additional context and contact support to ask the customer additional questions.
5. Roundabout communication and data gathering continue.
6. PM may be unaware there’s already another in progress for the same request; or if they do, they are the only one who is aware.
7. PM triages and determines priority.
8. Assuming this is a priority, engineering will begin work.
9. The customer asks for an update which is handled by support who asks PM who asks for engineering.
10. Everyone faces a lack of information, latency, context switching, and a whole lot of “work suck”.

Does this sound efficient? No. Does this sound like a horrible experience for all involved parties? Yes.

What if the following scenario played out in the following manner?

1. The customer files a feature request.
2. The system gathers additional context and performs data augmentation.
3. The system looks for similar items that may or may not already be in progress.
4. If a record is the same as another, associate; otherwise, treat as its own.
5. PM triages a much smaller population of items thanks to clustering and deduplication.
6. As the item progresses through the cycle, all parties are automatically notified without the need for human interaction.
7. If other teams view the status they can view the history and progression of the item in the object itself, without having to ask someone.

Let’s look at what we just did here:

• Eliminated the burden on support through smart routing and system-based data gathering.
• Eradicated the context switching and constant polling for updates between the customer, support and PM.
• Eliminated noise to the PM by clustering similar items and deduplicating.
• Made the whole process much more efficient.

So how do you do this?

• Intelligent routing and data gathering/augmentation.
• Intelligent notifications.
• Smart clustering of similar and related items.
• A system where all teams can collaborate on.

Learn more with Why you Should be Looking at Support Differently

Generative AI changes everything

Generative AI will likely be looked at in the future in the same vein as the invention of the combustion engine and the internet: something revolutionary that changed the way people do things.

In the context of support, this is the key enabler for most of the other items. For example, with the shift to self-service and chat-based interactions, we can enable customers to ask questions or interact with a model that can interpret (NLP) and respond in natural language. When done correctly, the customer may not actually be able to differentiate between interacting with a model and a human.

With embeddings and fine-tuning we can feed data like the following:

• Customer details including preferences, tone, and products/services they are using.
• Recent alerts/events which may be correlated with the customer.
• Previous interactions.
• Docs, APIs and KBs.

This enables a very customized interaction as the model can leverage all of these items to determine which questions it asks as well as how it structures its response.

Historically you’d be given a form or series of decision tree choices that led to something that likely didn’t solve your problem and led to you requesting a human. This all changes now.

Depending on the customer, we may already know what products or services they leverage. We may have context regarding recent alerts or events.

Hyper-personalization becomes a reality

For years we have talked about providing a “personalized” experience to our customers, however, this has been very generic and superficial (e.g., “Hi <insert name here>” on webpages). Is that a personalized experience? No.

With the internet, we now have a ton of data on our customers, their likes, their tone, and their interactions (this is one good thing social platforms provide). By pairing this public knowledge with the knowledge we have about the user on our systems (e.g. usage, alerts, interactions) and feeding that into an AI model, a personalized experience can now become a reality.

This also isn’t just for customers but applies internally just as much. For example, we can correlate alerts and recent code changes to notify an engineer that a recent commit may have broken something. We can cluster items into more macro items for easier consumption. We can determine ticket routing based on the skills of the engineer and the traits of the problem.

For example, let’s take the following:

• The customer has a problem with a page on the website.
• We can provide a proactive “chat” with them that we noticed the issue and ask if they need support.
• Using our knowledge of the customer, the page, and the alert we can determine the necessary information and ask the customer for certain details.
• The system gathers additional context and augments the data.
• Using this context the system can provide some potential resolutions.

Now, let’s say we weren’t able to deflect and human interaction is necessary:

• The customer or system escalates the item to a human. Based on the traits of the problem, the skills and the workload of the engineers, the system can determine where it gets routed.

TL;DR

• Just like technology, customers and support are evolving (or need to).
• Customers are looking for a more self-service support model.
• Chat and social will overtake email and phone as the primary communication channel.
• GenAI will drastically change user expectations of systems, and how supporting teams and systems work.
• Given the evolution and introduction of GenAI, customers will expect hyper-personalized interactions, where the system and agent can know much more details about the user, tone, and their interactions. This will change customers expectations and they will expect things to be personalized.