Aampe gives apps the power to learn what users want by making choices about when and how to talk with users. The learning happens by precisely monitoring those users’ responses in terms of their actions in the app.
In other words, to message effectively we have to first know what our precise goals are. One of the many things that makes Aampe a UI-enhancement system rather than just another messaging system is that we don’t pay attention to notification clicks (unless you really want us to...but that would be living far below your means).
Apps operate on the basis of events - clicks and actions the user takes that are recorded in the app’s back-end and database. Those events often correspond to actual business goals. For example, we work with a fitness app that allows users to schedule runs and compete with other runners. That app has an event that fires when a user schedules a run, and another event when a user actually completes a run - both behaviors our customer would like to see more of.
Every event is one step in a user journey. If you Google something like “user journey mapping”, what you see will typically be unrealistically clean:
Those maps are usually made by product managers who are trying to show the journeys they want their users to take, which is really only a small subset of the many journeys users actually take. You may want all your users to go from A to B to C, but reality looks more like this:
User journeys are extremely important because, even though something like “Schedule a Run” might be your end goal, some events are steps in the user journeys that lead to that goal. Some of those earlier events may be leading indicators of success that we should pay attention to, while other events don’t have much to do with the goal at all.
Aampe analyzes all of the actual user journeys an app’s users traverse in order to automatically incorporate both explicit goals as well as those goal’s leading indicators into our learning and optimization.
For example, this is a graph representation of the full user journey map for the running app:
Each event is organized in terms of the proportion of user journeys that feed into it - the largest blue dot represents the event that most often acts as a destination for user journeys. In this case, the most-common destination is the “Run Signed Up” event. However, the very next event is “Application Backgrounded”, which is what happens when the user switches to look at another app. Just because journeys feed into an event doesn’t mean that we should optimize our messaging to increase that particular event or journey. That’s why we need explicit goals.
For example, let’s say we don’t care as much about users signing up for a run as we do about users actually running. We can choose the “Start Run Pressed” event as our goal and then use the Journey Graph we saw above to score all of the other events in the system in terms of how reliably they feed into that milestone:
The goal event of “Start Run Pressed”, naturally, receives the highest weighting, but other leading indicators, such as “Waiver Agreed”, “Code Success”, and some (but not all) onboarding events also receive a substantial amount of weight.
Say we’re less interested in users starting a run and more interested in completing a run. Well, there’s a “Run Completed” event in the app for that:
This time, the higher weighted events are “App Sleeping” (because you’re running), “Medal Earned”, “Fun Image Found”, “Listen to your own music Pressed”, and so on.
These journey weights are important because they give our machine learning models - the core of Aampe’s learning system - more material to work with. The models are smart enough to be able to look at both the explicit goals we’ve set, as well as the implicit weights of all other events based on the explicit goals, and balance that information when deciding what works and what doesn’t.
In most cases, the real-world journeys taken by an app’s users are a tangled mess. Users jump between events that aren’t obviously in a single flow, skip steps that the app’s product marketers probably thought were key, give very promising signals of intent and then suddenly drop off the radar, and the list goes on. All of that is actually very powerful.
An app usually has only a few really key KPIs, centered on things like revenue, growth, retention, and engagement with the core value offered by the platform. It’s simple to look through the app events and designate as goals those events that align with the businesses’s KPIs. But by leveraging real - not ideal - user journeys to weight every event in the app in terms of the part it plays in moving users forward toward those goal events, we turn every event in the app into a sensor that our learning system pairs with notifications to learn what timing and content influences user behavior. That allows us to personalize our communication with every single user.