Respectlytics Respect lytics
Start Free Trial
Menu
Conversion Optimization Product Analytics Algorithm Technical Deep-Dive

How We Auto-Discover Conversion Paths
(No Manual Funnels)

β€’ 11 min read

Manual funnel configuration typically wastes 5-10 hours per analysis. You define expected steps, wait for data, discover gaps, add missing events, and repeat. Automatic conversion path discovery works in reverse: the algorithm analyzes which sessions converted, identifies common patterns, and surfaces the real journeys users takeβ€”including paths you never thought to track.

Every analytics platform promises "funnel analysis." What they actually deliver is a configuration screen where you manually define steps, hope you guessed the user journey correctly, and wait weeks to discover you missed a critical event.

We took a different approach. Instead of making you guess how users reach conversion, we analyze the sessions that actually converted and tell you what they have in common.

πŸ”§ The Manual Funnel Problem

Here's how traditional funnel analysis works in most analytics tools:

The Traditional Process

  1. 1 Hypothesis: You guess the user journey. "Users probably go: App Open β†’ View Products β†’ Add to Cart β†’ Checkout β†’ Purchase"
  2. 2 Configuration: You spend 1-2 hours setting up funnel steps in Mixpanel/Amplitude/Firebase
  3. 3 Wait: You need 1-2 weeks of data collection before results are meaningful
  4. 4 Discovery: You realize you forgot to track view_product_details between viewing products and adding to cart
  5. 5 Repeat: Add the missing event, redeploy, wait another 1-2 weeks

This cycle typically consumes 5-10 hours per funnel analysis. And here's the real problem: you only discover paths you already hypothesized.

⚠️ The Hidden Cost

Manual funnels show you what you expected to see. They never reveal the user who discovered your pricing page through the Settings menu, or the one who converted after visiting Help documentation. Your assumptions become your blind spots.

πŸ” How Automatic Path Discovery Works

Automatic path discovery inverts the traditional funnel process. Instead of starting with a hypothesis, you start with outcomes:

❌ Traditional (Hypothesis-First)

  1. 1. Define expected path
  2. 2. Configure funnel
  3. 3. Measure against expectations
  4. 4. Miss unexpected journeys

βœ… Auto-Discovery (Outcome-First)

  1. 1. Identify converted sessions
  2. 2. Extract event sequences
  3. 3. Find common patterns
  4. 4. Discover unexpected paths

The key insight: let your data tell you the story, instead of testing your assumptions against data.

What the Algorithm Reveals

When you run automatic path discovery on your conversion data, you get:

  • βœ“ Most common conversion paths β€” Ranked by frequency, showing which journeys actually lead to conversion
  • βœ“ Unexpected journeys β€” Paths you never configured but users actually take
  • βœ“ Path conversion rates β€” Which journeys have the highest success probability
  • βœ“ Drop-off points β€” Where non-converting sessions diverge from converting ones
  • βœ“ Conversion lift by event β€” Which events correlate most strongly with conversion

βš™οΈ The Algorithm Explained

Here's how the automatic path discovery algorithm works at a technical level:

Step 1: Define Conversion Events

First, you mark which events represent successful conversions. This is the only configuration required: 

# Define what "conversion" means for your app
conversion_events = [
    "purchase_completed",
    "subscription_started",
    "trial_activated"
]

Step 2: Group Sessions by Outcome

The algorithm partitions all sessions into two groups: 

# Pseudocode: Partition sessions
for session in all_sessions:
    if contains_any(session.events, conversion_events):
        converted_sessions.append(session)
    else:
        non_converted_sessions.append(session)

Step 3: Extract Event Sequences

For each session, we build an ordered sequence of events: 

# Session ABC (converted)
["app_opened", "home_viewed", "product_viewed", "add_to_cart", "checkout_started", "purchase_completed"]

# Session DEF (converted)
["app_opened", "search_used", "product_viewed", "add_to_cart", "purchase_completed"]

# Session GHI (converted)
["app_opened", "notifications_opened", "promo_clicked", "product_viewed", "purchase_completed"]

Step 4: Identify Common Patterns

The algorithm uses frequency analysis to find recurring subsequences in converted sessions. This is similar to finding common n-grams in text analysis: 

# Common patterns discovered
patterns = {
    ["product_viewed", "add_to_cart", "purchase_completed"]: 847 # sessions,
    ["search_used", "product_viewed", "purchase_completed"]: 312 # sessions,
    ["promo_clicked", "product_viewed", "purchase_completed"]: 156 # sessions,
    ["help_viewed", "pricing_viewed", "purchase_completed"]: 43 # sessions β€” unexpected!
}

Step 5: Calculate Conversion Lift

For each discovered pattern, we calculate how much more likely sessions are to convert when they contain that pattern: 

# Lift calculation
baseline_conversion_rate = 3.2%

# Sessions with "help_viewed β†’ pricing_viewed" pattern:
pattern_conversion_rate = 18.7%
lift = (18.7 - 3.2) / 3.2 = +484% # πŸ”₯ High-value discovery

πŸ’‘ The Insight That Matters

In this example, the help_viewed β†’ pricing_viewed path only appears in 43 sessionsβ€”but those sessions convert at 5.8x the baseline rate. A manual funnel would never have discovered this because you wouldn't think to configure "Help β†’ Pricing" as a conversion path.

⚑ Why Session-Based Analytics Makes This Easier

Session-based analytics is particularly well-suited for automatic path discovery. Here's why:

🎯 Natural Boundaries

Sessions have clear start and end points. You're analyzing a single conversion attempt, not trying to stitch together months of user behavior. This makes pattern detection more accurate.

πŸ”’ No Identity Required

You don't need persistent user IDs to run path discovery. Each session is an independent data point. This works with privacy-first analytics architectures where you don't track users across sessions.

πŸ“Š Cleaner Signal

User-based funnels mix multiple intents: "User visited 47 times over 3 months before converting." Session-based analysis isolates the session where conversion actually happened, showing you the immediate trigger.

Traditional user-based analytics tries to answer: "What did User_123 do over months that led to conversion?" Session-based path discovery answers: "What do converting sessions have in common?" The second question is often more actionable.

πŸ“± Real-World Discovery Examples

Here are patterns that automatic path discovery commonly revealsβ€”patterns that manual funnels miss:

E-Commerce App

Expected: Browse β†’ Product β†’ Cart β†’ Checkout β†’ Purchase
Discovered: Wishlist β†’ Sale Alert Notification β†’ Product β†’ Purchase (skips cart)
Insight: Wishlist + notifications converts at 3x baseline rate. The "add to cart" step is optional for engaged users.

SaaS Mobile App

Expected: Sign Up β†’ Onboarding β†’ Use Feature β†’ Hit Limit β†’ Upgrade
Discovered: Settings β†’ Team Members (view limit) β†’ Compare Plans β†’ Upgrade
Insight: Users checking team limits convert at 4.2x the rate. The "hit feature limit" trigger you expected is less predictive than proactive plan comparison.

Fitness App

Expected: Free Workout β†’ Complete β†’ Paywall β†’ Subscribe
Discovered: Workout β†’ Share Achievement β†’ View Friend's Profile β†’ Subscribe
Insight: Social features drive subscriptions more than workout completion. Sessions with "share" events convert at 2.8x baseline.

πŸ› οΈ Implementation Guide

Here's how to implement automatic path discovery with session-based analytics:

Prerequisites

  • 1. Session IDs: Events must include a session identifier that links actions within the same session
  • 2. Timestamps: Events must be ordered chronologically within each session
  • 3. Conversion events: You must define which events represent successful conversion

Basic Implementation

Python Example

from collections import Counter
from itertools import combinations

def discover_conversion_paths(sessions, conversion_events, min_path_length=2):
    """
    Discover common paths in converted sessions.
    
    Args:
        sessions: List of sessions, each with session_id and events list
        conversion_events: Set of event names that indicate conversion
        min_path_length: Minimum events in a path (default 2)
    
    Returns:
        List of (path, frequency, conversion_rate, lift) tuples
    """
    
    # Separate converted vs non-converted sessions
    converted = []
    non_converted = []
    
    for session in sessions:
        event_names = [e['event_name'] for e in session['events']]
        if any(e in conversion_events for e in event_names):
            converted.append(event_names)
        else:
            non_converted.append(event_names)
    
    # Extract subsequences from converted sessions
    path_counts = Counter()
    for events in converted:
        # Get all contiguous subsequences
        for length in range(min_path_length, len(events) + 1):
            for i in range(len(events) - length + 1):
                path = tuple(events[i:i + length])
                path_counts[path] += 1
    
    # Calculate conversion rates and lift
    baseline_rate = len(converted) / len(sessions)
    results = []
    
    for path, count in path_counts.most_common(50):
        # Calculate conversion rate for sessions with this path
        sessions_with_path = count_sessions_containing_path(sessions, path)
        converted_with_path = count
        path_conversion_rate = converted_with_path / sessions_with_path
        lift = (path_conversion_rate - baseline_rate) / baseline_rate
        
        results.append((path, count, path_conversion_rate, lift))
    
    return results

Example Output

# Top conversion paths discovered
Path                                           Sessions  Conv.Rate  Lift
────────────────────────────────────────────────────────────────────
product_viewed β†’ add_to_cart β†’ purchase       847       12.4%      +287%
search_used β†’ product_viewed β†’ purchase       312       9.8%       +206%
promo_clicked β†’ product_viewed β†’ purchase     156       15.2%      +375%
help_viewed β†’ pricing_viewed β†’ purchase       43        18.7%      +484%  ← High lift!
settings β†’ team_members β†’ compare_plans       29        22.1%      +590%  ← Unexpected

⚠️ Limitations and Trade-offs

Automatic path discovery is powerful, but it has limitations:

Cross-Session Journeys

Session-based analysis can't track users who research across multiple sessions before converting. If your typical customer visits 5 times over 2 weeks before purchasing, you'll only see the final conversion sessionβ€”not the research sessions.

Correlation vs. Causation

High lift doesn't mean the event caused conversion. Users who view Help documentation might already be more committed. Path discovery shows correlation; determining causation requires additional analysis or experimentation.

Sample Size Sensitivity

Rare paths with high lift might be statistical noise. A path with 10 sessions and 50% conversion rate sounds impressive until you realize 5 conversions isn't statistically significant. Always consider sample size alongside lift.

Event Granularity

The quality of discovered paths depends on your event taxonomy. If you track button_clicked instead of upgrade_button_clicked, path analysis loses precision. Descriptive event names produce better insights.

❓ Frequently Asked Questions

Q: How many sessions do I need for meaningful path discovery?

As a rule of thumb, you need at least 100 converted sessions to start seeing reliable patterns. For statistically significant lift calculations, aim for 500+ converted sessions. Less than that, and rare paths will dominate with potentially misleading lift scores.

Q: Should I remove common events like "app_opened" from analysis?

Yes. Universal events that appear in every session add noise without insight. Filter out app_opened, session_started, and similar ubiquitous events before running path analysis.

Q: Can I use this with user-based analytics?

Yes, but you'll need to decide how to handle users with multiple sessions. One approach: only analyze the session where conversion occurred. Another: analyze the last N events before conversion, regardless of session boundaries. Session-based analysis is cleaner because boundaries are natural.

Q: How do I handle multiple conversion events in one session?

If a session contains multiple conversion events (e.g., trial_activated then purchase_completed), you can either treat them as separate conversion types or analyze paths to the first conversion event only.

Q: How often should I run path discovery?

Run it after significant product changes (new features, UI redesigns) and periodically (monthly or quarterly) to catch shifts in user behavior. Paths that worked 6 months ago may no longer be dominantβ€”especially if you've changed the app.

πŸ’‘ Key Takeaways

  • β†’ Manual funnels waste time and miss insightsβ€”you only discover paths you already hypothesized
  • β†’ Automatic path discovery inverts the processβ€”start with converted sessions, find common patterns
  • β†’ Session-based analytics is ideal for path analysisβ€”natural boundaries, no identity required
  • β†’ High-lift, low-frequency paths are often the most valuableβ€”they reveal unexpected conversion drivers
  • β†’ Descriptive event names enable better discoveryβ€”upgrade_button_clicked beats button_clicked

Technical Note

The algorithms and examples in this post are illustrative. Production implementations may require additional optimizations for large datasets, handling of edge cases, and statistical validation. Actual conversion path discovery in Respectlytics includes additional filtering, significance testing, and visualization features not covered in this overview.

Related Reading

Ready to discover your real conversion paths?

Stop guessing how users convert. Let your data show you the actual journeys.

View SDK Documentation β†’ See Pricing