You've built a great product. Users sign up. Then they get confused, overwhelmed, or lost—and churn before experiencing value.
In-app guidance—tooltips, product tours, checklists, and contextual help—can bridge that gap. When done right, it accelerates activation, reduces support burden, and helps users discover features they didn't know existed.
When done wrong, it's annoying, intrusive, and ignored.
The challenge: How do you guide users without handholding? How do you educate without interrupting?
This guide covers in-app guidance best practices, when to use (and not use) different tactics, and real-world examples from top PLG companies.
What Is In-App Guidance?
In-app guidance is any UI element or flow that helps users understand, navigate, or use your product—without leaving the product.
Common types:
- Tooltips: Small pop-ups explaining UI elements
- Product tours: Step-by-step walkthroughs of features
- Hotspots: Pulsing dots or badges highlighting new features
- Checklists: Progress-driven task lists (onboarding flows)
- Empty states: Helpful messages when there's no data
- Modals/Announcements: Full-screen or overlay messages
- Contextual help: Inline links to docs, videos, or support
Goal: Help users achieve their goals faster, with less friction.
When In-App Guidance Works (and When It Doesn't)
✅ Use In-App Guidance When:
1. Users are new and need orientation
- First login, empty state, unfamiliar UI
- Example: "Click here to create your first project"
2. Features are complex or multi-step
- Workflows with 3+ steps that aren't obvious
- Example: "To set up integrations: 1) Connect account, 2) Map fields, 3) Test sync"
3. You're launching new features
- Users won't discover them organically
- Example: Hotspot badge on new "AI Assistant" button
4. Users are stuck or making errors
- Detected via behavior (repeated failed attempts, abandoned flows)
- Example: "Having trouble? Here's how to import data"
5. You want to drive adoption of high-value features
- Features that correlate with retention/expansion
- Example: "Teams that use [feature X] see 3x more value. Try it now."
❌ Don't Use In-App Guidance When:
1. The UI is self-explanatory
- Obvious buttons, standard patterns (search, navigation)
- Users don't need a tooltip on "Save" or "Cancel"
2. You're explaining every element
- Tooltip overload = users dismiss everything
- Example: Tooltip on every button in the toolbar
3. You're forcing users through tours
- Blocking modals that trap users ("Complete this tour before using the product")
- Users resent being forced; they'll skip without learning
4. Returning users don't need it
- Once someone understands the product, guidance becomes noise
- Example: Showing onboarding tour every time they log in
5. It's a lazy substitute for good design
- If your UI needs constant explanation, fix the UI—don't add tooltips
Golden rule: Guidance should be helpful, not intrusive. If users are dismissing it, you're doing it wrong.
Types of In-App Guidance & Best Practices
1. Tooltips
What: Small pop-ups that appear on hover or click, explaining UI elements
When to use:
- Complex icons or buttons (not immediately clear)
- Technical features (e.g., "API rate limit: 1000 calls/hour")
- First-time user guidance (disappear after first interaction)
Best practices:
- Short and clear: 1-2 sentences max
- Actionable: Tell users what to do, not just what it is
- Dismissible: Let users close it
- Context-aware: Show only when relevant (first use, specific page)
Example:
Bad tooltip: "This is the dashboard"
Good tooltip: "View all projects here. Click 'New Project' to get started."
Tools: Native CSS, Tippy.js, Popper.js
2. Product Tours (Walkthroughs)
What: Step-by-step guided tours that walk users through features or workflows
When to use:
- Onboarding new users (first-time experience)
- Introducing complex features (multi-step processes)
- Launching major product updates
Best practices:
- Short: 3-5 steps max (users will skip long tours)
- Skippable: Always offer "Skip tour" or "I'll explore on my own"
- Interactive: Let users do the action, don't just show them
- Progressive: Show just enough to get started, not everything
Example: Slack's onboarding tour
- Step 1: "Send your first message"
- Step 2: "Create a channel"
- Step 3: "Invite a teammate"
- Done in < 2 minutes
Avoid:
- 10-step tours that explain every feature (users abandon)
- Blocking modals that trap users (frustrating)
- Auto-playing on every login (annoying for returning users)
Tools: Appcues, Pendo, Intercom Product Tours, WalkMe
3. Hotspots (Feature Highlights)
What: Pulsing dots, badges, or "New" labels that draw attention to features
When to use:
- Announcing new features
- Highlighting underutilized high-value features
- Prompting specific actions
Best practices:
- Subtle: Pulsing dot or badge, not a giant flashing banner
- Dismissible: Users can close it after seeing it
- Linked to action: Clicking should explain or demo the feature
- Time-limited: Don't show forever (1-2 weeks or until clicked)
Example: Gmail's hotspot on new "Smart Compose" feature
- Small pulsing dot on compose button
- Tooltip: "Try Smart Compose—AI-powered email drafts"
- Disappears after first use
Avoid: Too many hotspots at once (cluttered, overwhelming)
4. Onboarding Checklists
What: Progress-driven task lists that guide users through setup or activation
When to use:
- Onboarding (getting users to their aha moment)
- Multi-step setup processes (integrations, configurations)
- Feature adoption campaigns
Best practices:
- 3-5 tasks max: Achievable, not overwhelming
- Show progress: "2 of 4 complete (50%)"
- Gamified: Checkmarks, animations, rewards (dopamine hit)
- Optional tasks: Let users skip non-essential steps
Example: LinkedIn profile completion
- "Add a photo" ✅
- "Add work experience" ☐
- "Connect with 5 people" ☐
- Result: 20% increase in profile completions
Evidence: Humans love completing checklists (Zeigarnik effect—unfinished tasks create tension).
Tools: Build natively, or use Appcues, Chameleon, Pendo
5. Empty States
What: Helpful messages/CTAs when there's no data or content yet
When to use:
- New user with blank dashboard
- Feature they haven't used yet
Best practices:
- Explain what's missing: "You don't have any projects yet"
- Clear CTA: "Create your first project" (button)
- Show what it will look like: Preview or sample data
Example: GitHub empty repo state
- "Get started by creating a new file or uploading an existing one"
- Button: "Create new file"
- Visual: Shows what a populated repo looks like
Avoid: Blank screens with no guidance (users don't know what to do)
6. Modals & Announcements
What: Full-screen or overlay messages (often for major updates or alerts)
When to use:
- Critical updates (security, breaking changes)
- Major new features (product launches)
- Upsell opportunities (premium feature promotions)
Best practices:
- Rare: Don't overuse (modal fatigue)
- Dismissible: Always provide a close button
- Valuable: Only show for important, relevant info
- Time-limited: Don't show repeatedly to the same user
Example: Notion AI announcement
- Modal on first login after launch: "Introducing Notion AI"
- CTA: "Try it now" or "Maybe later"
- Doesn't show again once dismissed
Avoid:
- Frequent modals (users develop "banner blindness")
- Non-dismissible modals (traps users)
- Generic messages ("We updated our terms of service"—users don't care)
7. Contextual Help (Inline Docs & Support)
What: Links to help docs, videos, or chat—embedded where users need them
When to use:
- Complex forms or settings
- Feature pages with lots of options
- Error states
Best practices:
- Inline links: "Learn more about API keys" (opens help doc)
- Embedded videos: 2-3 minute explainers
- Proactive chat: "Need help with this?" (live chat prompt)
Example: Stripe API docs
- Every setting has inline documentation
- Code examples embedded directly in the UI
- Result: Self-serve adoption, low support volume
Benefit: Users get help without leaving the product (no context switching)
Designing Effective In-App Guidance
Principle 1: Context Over Interruption
Show guidance when and where it's relevant—not randomly.
Bad: Tooltip appears on every page load Good: Tooltip appears first time user hovers over a new feature
Trigger-based guidance:
- First login → onboarding tour
- Tried to use gated feature → upgrade prompt
- Made an error → contextual help tip
- Idle for 30 seconds on a page → "Need help?" chat prompt
Principle 2: Progressive Disclosure
Don't explain everything at once. Reveal complexity gradually.
Example: Notion onboarding
- First session: Create a page, add text
- Second session: Introduce blocks and databases
- Third session: Show templates and collaboration
Why it works: Cognitive load is manageable. Users learn as they grow.
Principle 3: Show, Don't Tell
Let users do the action, don't just explain it.
Bad tour: "This button creates projects. This button deletes them. This button shares them." Good tour: "Let's create your first project. Click here." (User clicks → project created) "Great! Now invite a teammate."
Result: Learning by doing = better retention.
Principle 4: Respect User Agency
Always offer escape hatches:
- "Skip tour"
- "I'll explore on my own"
- "Don't show this again"
Users who feel trapped will resent your product.
Principle 5: Test and Iterate
A/B test guidance:
- Tooltip vs. no tooltip
- 3-step tour vs. 5-step tour
- Checklist vs. free exploration
Measure:
- Completion rate (did users finish the tour?)
- Activation rate (did guidance improve activation?)
- Dismissal rate (are users skipping it?)
If users dismiss your guidance 80% of the time, it's not helping.
Common In-App Guidance Mistakes
Mistake #1: Too much guidance Tooltip on every button = noise. Users develop "tooltip blindness."
Mistake #2: Forced tours Blocking modals that prevent use until completed = frustration.
Mistake #3: Showing to returning users Once someone knows the product, stop showing onboarding.
Mistake #4: Generic messaging "Welcome to [Product]!" is useless. Be specific: "Let's create your first project."
Mistake #5: No segmentation A designer and an engineer have different needs. Personalize guidance by role or use case.
Mistake #6: Using guidance as a crutch for bad UX If your product needs constant explanation, fix the design—don't add more tooltips.
Real-World Examples
Example 1: Slack
Onboarding tour:
- 3 steps: Send message → Create channel → Invite teammate
- Interactive (users perform actions)
- Skippable
- Result: 50%+ of users complete it, high activation
Example 2: Figma
Feature hotspots:
- New "Dev Mode" feature launched
- Pulsing badge on toolbar
- Tooltip: "Introducing Dev Mode—design handoff for developers"
- Result: 35% of users tried the feature in first week
Example 3: Superhuman
Onboarding checklist:
- "Complete your profile"
- "Connect Gmail"
- "Learn 3 keyboard shortcuts"
- Progress bar drives completion (gamification)
- Result: 80%+ checklist completion, fast time-to-value
Tools for In-App Guidance
No-code platforms:
- Appcues: Tours, checklists, hotspots
- Pendo: Product tours, in-app messaging, analytics
- Intercom Product Tours: Tooltips, tours, announcements
- Chameleon: In-app guidance and surveys
- WalkMe: Enterprise-grade walkthroughs
Build custom:
- Intro.js, Shepherd.js: Open-source tour libraries
- React Joyride: React-specific guided tours
- Driver.js: Lightweight tour library
Start simple: Use native tooltips and modals. Graduate to platforms as you scale.
The Bottom Line
In-app guidance is a powerful tool—but only when used thoughtfully.
The best guidance:
- Appears when and where users need it (contextual)
- Helps users achieve their goals faster (outcome-focused)
- Respects user agency (skippable, dismissible)
- Tests and iterates (data-driven optimization)
The worst guidance:
- Interrupts unnecessarily (modal spam)
- Explains the obvious (tooltip overload)
- Forces users through steps (trapped tours)
- Ignores returning users (shows onboarding forever)
Start by identifying where users get stuck (analytics, support tickets, session recordings). Add guidance at those friction points. Measure impact. Iterate.
Your goal isn't to teach users everything—it's to help them experience value fast. Guide, don't lecture.
Want to identify where users need guidance? Pelin.ai analyzes support tickets and user feedback to surface common onboarding friction points—helping you build in-app guidance that solves real user problems, not imagined ones.