Tailoring Flows to the user insights
This section describes how integrate Questions into your Flow, configure them and define the decision logic to tailor the Flow based on users responses
Flows allow you to tailor the user journey based on user insights, enabling deeply personalized experiences that drive higher engagement and conversion. For your users, this means a more relevant and frictionless journey - from onboarding to paywall exposure - aligned with their needs, goals, or motivations. Instead of receiving a generic flow, each user is guided through content, features, and offers that actually resonate with them.
For you, this unlocks the ability to deliver differentiated, intent-based journeys in no-code without duplicating screens or hardcoding decision logic. It simplifies experimentation, maximizes reusability, and makes personalization scalable - resulting in better performance across key KPIs like opt-in rates, trial starts, and subscriptions.
Setting up personalized Flows based on user insights
Creating a personalized user journey with Flows and Insight Quizzes is a powerful way to guide users based on what truly matters to them. The process involves three key steps:
- Design Screens with a Quiz Component and associated Data model
Create interactive screens using the Question component to ask meaningful questions—about user goals, preferences, challenges, or context. Each Quiz is linked to an Insight Quiz, which standardizes how responses are tracked and reused across Flows. - Define and Structure the Answers
For each possible answer, define a localizable label (Text) and a unique identifier (value). This value is stored in an Insight Attribute, creating a structured data point (e.g., "user_goal": "sleep"). These attributes form the foundation for segmentation and logic throughout the user experience. - Create Audiences and Route with Transitions
Use the captured Insight Attributes to define Audiences. Then configure 1-to-many Transitions from the Question screen, routing each audience to a personalized Screen, message, or offer that best matches their profile.
This approach transforms static flows into dynamic, insight-driven journeys—improving relevance, engagement, and conversion from the very first interaction.
1. Design Screens with a Question Component linked to an Insight Question
Question components inside the Screen Composer must be associated with an Insight Question, identified by a unique Question ID.
- The Question component is the visual element shown to users, allowing them to provide input during their journey.
- The Insight Question, managed in the User Insights section, defines the structure, content, and logic of the question - determining how responses are structured, stored, and reused across experiences.
By linking a Question component to an Insight Question, you ensure that all responses are consistently collected across Screens, languages, and Flows, making them actionable for analytics, segmentation, and personalization.
2. Define and Structure the Answers
Each Answer in a Question is composed of two elements:
- A
Text
, which is localizable and displayed to the user by the SDK - A
value
, which is a unique, language-independent identifier submitted to our platform when users respond to the Question.
This separation lets you display answers in multiple languages while ensuring consistent tracking across locales.
Example:
For the Question “What would you like some help with?”
# | Displayed Text | Submitted value (value ) |
---|---|---|
Answer 1 | Practicing selfcare | selfcare |
Answer 2 | Building healthy relationships | relationships |
Answer 3 | Sleeping soundly | sleeping |
Answer 4 | Releasing stress | stress |

If the Question allows multiple selections, the values are stored as an array of strings in the associated Insight Attribute.
3. Create Audiences and Route with Transitions
When users answer a Question, their selected values are stored as Insight Attributes—which can then be used to personalize navigation within your Flow.
If you want to configure a conditional Transition—i.e., a transition that dynamically routes users to different Screens based on their responses—follow these steps:
- Link the action cartridge to multiple destination Screens
Attach several possible target Screens to the same interactive component (e.g. a Continue button). - Edit the Transition logic
Click on the Transition to open the configuration panel, then:- Create Audiences based on Insight Attributes
For example: target users who selectedstress
in the Question Insight "What would you like some help with?" - Assign a destination Screen to each Audience
Route each Audience to a dedicated Screen that delivers the most relevant message, feature, or offer based on their declared intent.
- Create Audiences based on Insight Attributes
- Order the Routes
Prioritize Audiences by ordering the Routes—just like you would in a Placement—ensuring the most specific conditions are evaluated first.
This setup allows you to deliver deeply personalized journeys—tailored not just by behavior, but by declared user intent—without duplicating screens or flows.

Route users to personalized Screens based on their responses - using Audiences and Conditional Transitions to tailor the journey in real time
Fetching the user insights in the app
Purchasely Questions offer a powerful, no-code way to collect structured user insights directly within your app - whether it's preferences, goals, motivations, or feedback. These insights are instantly accessible in the Purchasely Console for visualization and analysis, and can also be used to collect user data, power backend logic, or enrich third-party integrations.
Thanks to a unified mechanism - the listener for Custom User Attributes - you can create and manage unlimited Questions via the Console, while still capturing user responses in real time across your systems. No additional SDK logic is required per Question, making the solution both scalable and low maintenance.
How to fetch the user insights in the app?
Upon the submission of the user's Answer(s), if the Question Insight has been associated with an Insight Attribute, the app will be notified via an Event Listener for Custom User Attributes.
class UserAttributeHandler: PLYUserAttributeDelegate {
func onUserAttributeSet(key: String, type: PLYUserAttributeType, value: Any?, source: PLYUserAttributeSource) {
print("onUserAttributeSet: \(key) \(type) \(String(describing: value)) \(source)")
}
func onUserAttributeRemoved(key: String, source: PLYUserAttributeSource) {
print("onUserAttributeRemoved: \(key) \(source)")
}
}
Purchasely.setUserAttributeDelegate(UserAttributeHandler())
Purchasely.userAttributeListener = object : UserAttributeListener {
override fun onUserAttributeSet(key: String, type: PLYUserAttributeType, value: Any, source: PLYUserAttributeSource) {
Log.d(TAG, "User attribute added: $key, $type, $value from $source")
}
override fun onUserAttributeRemoved(key: String, source: PLYUserAttributeSource) {
Log.d(TAG, "User attribute removed: $key")
}
}
Purchasely.addUserAttributeSetListener((attribute: PurchaselyUserAttribute) => {
console.log('Attribute set:', attribute);
});
Purchasely.addUserAttributeRemovedListener(attribute => {
console.log('Attribute removed:', attribute);
});
// -- Definition of a Purchasely User Attribute -- //
export type PurchaselyUserAttribute = {
key: string;
value?: any | null;
type?: PLYUserAttributeType | null;
source?: PLYUserAttributeSource | null;
};
class MyUserAttributeListener implements UserAttributeListener {
@override
void onUserAttributeSet(String key, PLYUserAttributeType type, dynamic value, PLYUserAttributeSource source){
print("Attribute set: $key, Type: $type, Value: $value, Source: $source");
}
@override
void onUserAttributeRemoved(String key, PLYUserAttributeSource source) {
print("Attribute removed: $key, Source: $source");
}
}
Purchasely.setUserAttributeListener(MyUserAttributeListener());
The SDK provides:
- the
key
of the attribute - the
type
of the attributeString
for single answer QuestionsArray of Strings
for multiple answers Questions
- the
value
(String - single answer) orvalues
(Array of Strings - multiple answers) matching the Answers picked up by the user.
Value of the parameter source
After the submission of the MCQ, the parameter
source
as the valuepurchasely
to indicate to the app that the Custom User Attribute has been set by the SDK and not by the app.
How to send the insights to my backend?
Once the app has been notified through the event listener / delegate, you can execute your own code and associate the Insight Attribute returned and its value as a user property and/or send this to your backend.
This processing has to be done by your app. Purchasely does not provide a server to server integration to do it.
How to send the data to 3rd party integrations?
It's the same with 3rd party integrations. After fetching the Custom User Attribute and its value, associate it to the user and leverage the mobile SDK API of your 3rd-party platform to send it.
For instance, this can be achieved with the following platforms (the list is not exhaustive):
- Amplitude
- Braze
- MixPanel
- Iterable
- Clevertap
- OneSignal
- Batch
- Google Analytics for Firebase
- Piano analytics
- Airship
- MoEngage
- or any 3rd party SDK integrated inside your application
This processing has to be done by your app. Purchasely does not provide a server to server integration to do it.
You're all set!
Updated about 12 hours ago