Create More Power Users of Your SaaS With ChatGPT

When your users feel all-powerful in your product, they'll never churn. Give them superpowers.

·4 minute read
Cover for Create More Power Users of Your SaaS With ChatGPT

Power Users Don't Churn

What makes a user feel like a power user? I'd argue it's the feeling of knowing that they can achieve results that take "normal" users significantly longer. The feeling of breezing through something complex due to a mastery of the available toolset is a magic moment, and it keeps users retained.

Design trends, specifically the focus on simplicity and ease of use, have made it much trickier to give users the tools they need to feel the rush of being a power user. Every choice in favor of simplicity results in the exclusion of one of those tools, so software ends up being trivial to learn but impossible to feel like a master – and more importantly, impossible to execute the kinds of complex tasks that power users face on a regular basis. This is a significant tradeoff that isn't talked about enough. We try to cover it up with band-aid solutions like keystrokes, but it doesn't cut it.

This is entirely a UI/UX tradeoff. After all, any given software is technically capable of performing far more operations, and combinations of operations, than are available in the UI. But because of the perceived negative impact on simplicity and ease of use for the average user, those operations are excluded. So when a user faces a complex set of tasks, they have to go step by step, following a robotic process that takes forever. That feeling is what makes a user feel like a normie instead of a power user. And if they find another tool that lets them automate or optimize that, they'll churn for it.

I also want to make it clear that this UI/UX tradeoff is real – the solution isn't to add all the buttons and controls and modals and operations that your users might benefit from. Luckily, it turns out that LLMs outperform at covering these bases and giving your users the tools to become power users.

LLMs Excel Where Your UI Fails

LLMs are good at processing text and yielding more text. Applying these skills to the above problem set is simple. We need to:

  1. Be able to provide the list of available operations to the LLM, in a concise, plaintext format;
  2. Be able to provide the context around the user's request, such as the currently viewed list of documents in Notion's case;
  3. Allow the user to type in plaintext what they want to accomplish;
  4. Process the LLM's output into instructions for your SaaS using the provided list of available operations.

Putting this all together, you can give your user the power to type descriptions of their desired outcome in plain English, and convert that into a proposed list of actions to execute. If the user approves the list, you execute those instantly, saving the user hours of time and giving them that power-user-thrill.


Implementing the above is non-trivial, as you'll need to set up your integration with an LLM, figure out how to serialize and reverse serialize your application's context and operations into text, set up a chat-like UI for the user and tie it all together. It's certainly doable, but...

The Fast Way

At Rehance we've made it easy for you to cover your bases and retain your users. Define the available actions and context in our UI, and add our drop-in JS script to your site to get the chat interface up and running. Theme of the UI widget is customizable, and integration of the drop-in script should take a front-end engineer an hour or so depending on the number of operations you're looking to support. Check it out at

The Slow Way

Here's the roadmap:

  1. Define a set of actions. Each action needs to have a set of parameters. Only include the bare necessities, as too much complexity will confuse the LLM you use.
  2. Define the shape of the context that may be needed to perform the provided actions. The details here depend on your use case, so you'll need to figure out what shape works best for you. As with the actions, minimize the number of fields and keep the data types as simple as possible.
  3. Create a chat-like UI interface for your users. They should be able to enter text describing what they're looking to accomplish.
  4. Construct a prompt for an LLM, providing the context and actions, along with the user request. Process the response, and convert it into actual operations performed in your software application. Handle errors and edge cases appropriately.
  5. Run analytics on your users' prompts to figure out what actions they use the chat tool for most - these are likely the most frustrating parts of using your application.

Building this type of interface into every piece of software is a no-brainer. Text inputs won't replace traditional UIs by any means, but they can certainly cover all of its blind spots.