Create a Flow – Userpilot Knowledge Base

What a Flow Is (and Isn’t)

A Flow is an in-app experience that guides users through a job they’re trying to doonboarding, adopting a feature, completing setup, or discovering a new capability. Think of it as a helpful coworker who taps your shoulder at exactly the right moment and says, “Hey, here’s the next step,” then disappears before they start telling you their entire life story.

A Flow is not a substitute for product design or a “fix” for confusing UX. If users can’t find a core action because the UI is unclear, adding 12 tooltips is like putting neon sticky notes on a maze. Helpful? Maybe. A little haunting? Definitely.

The sweet spot: flows that reduce time-to-value by pointing users to the next best action, in context, using small, skippable steps.

Plan First: The Shortest Path to Value

Before you open any builder, decide what success looks like. The easiest way to build a Flow that converts is to define three things up front:

1. The user’s job-to-be-done: What are they trying to accomplish right now? (Not what you want them to admire.)
2. The “aha” moment: The moment they feel the product’s value. In a project tool, it might be “create a project + assign a task.” In analytics, it could be “connect data + see first chart.”
3. A measurable outcome: Activation rate, completion rate, time-to-value, feature adoption, or a key funnel step.

Pick one primary goal per Flow

Flows fail when they try to do everything: onboarding, feature launch, upsell, and emotional support. Keep it focused. If you need multiple outcomes, build multiple flows and target them appropriately.

Write your Flow like a recipe, not a lecture

Users don’t want a TED Talk from your tooltip. Use action-first steps: “Add your first teammate,” “Connect Stripe,” “Create your first dashboard.” If a step doesn’t change behavior, it’s probably trivia.

How to Create a Flow in Userpilot (Two Common Starting Points)

Userpilot generally gives teams two practical ways to start building: directly from your app using the builder (commonly launched via a browser extension), or from the Userpilot web app where you manage your engagement layer and flows.

Option A: Start from your web application (builder approach)

1. Open your web app (the one you’re adding in-app experiences to).
2. Launch the Userpilot builder (commonly from the extension icon in your browser toolbar).
3. Choose the UI pattern you want to add (e.g., tooltip, modal, slideout) and place it on the relevant element.
4. Add the next step and keep building until the user reaches the outcome.

Option B: Start from the Userpilot web app (Flows list approach)

1. Navigate to your flows area (often under something like Engagement Layer → Flows).
2. Click Create New Flow.
3. Pick a starting point (template or blank) and begin building steps.

Build the Flow structure: steps, patterns, and pacing

Most flows become a sequence of small, helpful moments. Common patterns include:

• Modals for a “big moment” intro (keep it short, offer skip).
• Tooltips for “do this next” guidance on a specific UI element.
• Slideouts when you need more room without blocking the whole screen.
• Checklists to give users a visible path and a sense of progress.

The rule of thumb: start broad (why it matters), then go narrow (what to click), then get out of the way.

Designing Steps Users Won’t Rage-Close

1) Decide the “interruption level” intentionally

Not every moment deserves a full-screen modal. If the user is mid-task, a tooltip is usually kinder. Save disruptive patterns for high-value moments: first login, major feature changes, critical setup.

2) Keep steps shortand make the next action obvious

Good Flow copy is like a great road sign: clear, brief, and placed right before the turn. Use one idea per step. If you find yourself writing “also,” you probably need another stepor less text.

3) Allow escape hatches (skip, dismiss, snooze)

Users want control. If you trap them in a tour, they’ll remember you the way people remember unskippable ads: forever, and not warmly.

4) Match your product’s voice (helpful, not hypey)

A Flow is not a billboard. “Welcome to the future of synergy!” is rarely the sentence that helps someone connect their data source. Use friendly clarity. A little personality is greatjust don’t bury the instruction.

5) Consistency beats creativity

Create a repeatable style for headers, buttons, and tone. The more consistent your flows look, the more users trust them as part of the product (instead of a pop-up ambush).

Targeting: Who Sees It, When, and Where

Targeting is where average flows become high-performing flows. The same message can be brilliant for a new user and annoying for a power user. Your job is to show the Flow only to the people who need it.

Start with audience segments

A practical segmentation strategy often uses a mix of:

• User attributes: role, plan, company size, lifecycle stage.
• Behavior: feature usage, completed events, adoption milestones.
• State: “has not connected integration,” “has not invited teammate,” etc.

Choose a trigger that matches intent

Triggers make your Flow feel “just-in-time” instead of “just-because.” Common trigger styles include:

• On page load (best for first-session onboarding or announcements).
• On element click (best for contextual help when a user is already exploring a feature).
• After an event (best for next-step nudges: “Great, now do this”).
• When a condition is met (best for personalized guidance and branching).

Set rules so the Flow doesn’t overstay its welcome

Smart frequency control prevents burnout:

• Show it once per user (or once per milestone).
• Stop showing after completion.
• Stop showing if the user already did the thing.

Make Your Flow Feel Personal with Logic

The difference between a basic tour and a high-performing Flow is often conditional logic. Real users don’t move in a straight line. Some already completed step 2. Some skipped step 1 but still want the outcome. Logic lets your Flow adapt instead of scolding users for being human.

Use logic to skip, route, or shorten the journey

Practical use cases:

• Skip completed steps: If the user already connected an integration, don’t explain how to connect it.
• Route by role: Admins see setup steps; contributors see “how to do your first task.”
• Handle multiple paths: If the feature can be set up two ways, route users based on what they click.

When you build logic, you’re not making your flow “more complex.” You’re making the user’s path less complex. Big difference.

Measuring Success: What to Track After You Publish

Publishing is not the finish line. It’s the moment you finally get data that tells you whether your assumptions were genius or… aspirational.

Core Flow metrics to watch

• Flow completion rate: Are users finishing the steps?
• Drop-off step: Which step causes exits?
• Time-to-value: Are users reaching the “aha” faster?
• Activation rate: What percent completes the key onboarding milestone?
• Feature adoption: Do users use the feature more after the Flow?

Diagnose issues like a scientist, not a poet

If completion is low, test a few common causes:

• Wrong timing: The Flow appears before the user cares.
• Too many steps: You built a museum tour, not a shortcut.
• Unclear CTA: Users don’t know what to click next.
• Bad targeting: Power users are being forced into “Welcome!” tours.
• UI drift: The product changed, the Flow didn’t.

Then iterate: shorten, retarget, rewrite, or split one Flow into two smaller ones. Your best Flow is usually version 3not version 1.

Examples: Flows You Can Build This Week

Example 1: New user “First Value” Flow (setup → outcome)

Goal: Reduce time-to-first-success.
Audience: New users who haven’t completed the key setup step.
Structure:

• Modal: “Let’s get your first project live in 2 minutes.”
• Tooltip: Point to “Create Project” button.
• Tooltip: Explain naming + template choice.
• Tooltip: Prompt “Invite teammate” (optional).
• Checklist: Show 3 items that lead to value (connect, create, share).

Pro tip: Put the checklist where users can find it again (not hidden inside a one-time tour).

Example 2: Feature discovery Flow (announcement → try it now)

Goal: Drive adoption of a new feature.
Audience: Users in a relevant plan/role, who haven’t used the feature.
Structure:

• Slideout: “New: Saved Views. Filter once, reuse forever.”
• Tooltip: Highlight “Save view” action.
• Tooltip: Show where saved views appear later.
• Exit step: “Want this to show up automatically? Turn on defaults.”

Example 3: “Rescue” Flow for stuck users (detected friction → help)

Goal: Reduce support tickets and frustration.
Audience: Users who repeatedly visit a page but don’t complete an action (a common friction signal).
Structure:

• Tooltip: “Need help connecting your data? Here’s the fastest method.”
• Step-by-step tooltips: point to exact fields
• Optional resource: link to a help widget or resource center

Example 4: Expansion Flow (value proven → upgrade moment)

Goal: Encourage upgrade after value is clear.
Audience: Users hitting a usage limit or completing a high-value milestone.
Structure:

• Slideout: “You’ve hit 90% of your monthly seats.”
• Tooltip: Show how to add seats (and what happens next).
• CTA: “Compare plans” (keep the copy factual, not guilt-based).

Field Notes: of Hard-Earned “Create a Flow” Experience

Teams usually think “Create a Flow” means “drag some tooltips onto the UI and call it onboarding.” And suretechnically you created a flow. You also technically cooked dinner if you ate cereal standing over the sink. But if you want a Flow that performs (and doesn’t get quietly ignored), here are the patterns teams learn after shipping a few real ones.

First: your first Flow will be too long. Almost everyone builds the “grand tour” because it feels responsible: “We should show them everything!” Users, however, did not sign up for Everything. They signed up for a result. The fix is simple: take your draft Flow and cut it in half. Then cut it again. Keep only the steps that directly move the user to the outcome. If a step starts with “By the way,” it belongs in a help article, not in a Flow.

Second: timing beats clever copy. A perfectly written tooltip shown at the wrong moment performs like a joke told during a fire drill. The best flows appear when intent is obvious: right after signup, right after a feature click, or right after the user completes a milestone and needs the next step. If you can tie a flow to behavior (not just “page visited”), your completion rates usually improve without touching a single word of copy.

Third: targeting is where “helpful” becomes “personal.” The biggest win often comes from splitting one Flow into two: one for admins, one for everyone else; one for trial users, one for paid; one for “has never done X,” one for “did X but didn’t do Y.” Users don’t hate guidancethey hate irrelevant guidance. The moment your Flow respects what the user already knows, it starts feeling like part of the product, not an interruption.

Fourth: expect “UI drift” and plan for it. Products change constantlybuttons move, labels change, pages get redesigned. That’s great for your product, but it can break a Flow overnight. The most resilient teams treat flows like living assets: they set a lightweight review cadence (especially after releases), test key flows on staging, and keep a short “critical flows” list that gets checked before big launches. This prevents the classic experience: a tooltip pointing confidently at… empty space.

Fifth: measure one thing per Flow and iterate like you mean it. If your goal is activation, don’t celebrate “views.” Watch completion rate, drop-off step, and whether the user actually performs the target action afterward. When something underperforms, try a single change at a time: shorten the flow, change the trigger, rewrite the first step, or adjust the segment. Versioning isn’t a sign you failedit’s how you get to the Flow that feels effortless.

Finally, remember the real secret: a Flow isn’t a tour. It’s a shortcut. When you build it like a shortcutfast, relevant, and optional users don’t just complete it. They thank you by quietly succeeding, which is the highest compliment software can receive.