Interactive product demos are everywhere, but most of them feel generic. If you want your demo to actually help people see themselves using your tool, you need to get personal. That's where branching logic in Navattic comes in. This guide cuts through the fluff and shows you how to build demos that adapt to each visitor—without driving yourself nuts.
This is for anyone building demos in Navattic who wants to go beyond a boring, one-size-fits-all flow. If you want prospects to think, “Hey, this actually matches what I’d do,” keep reading.
Why bother with branching logic?
Let’s cut to the chase: most product tours are ignored because they're irrelevant. Branching logic fixes this by letting you create “choose your own adventure” demos:
- Different roles, different flows: Show admins one experience, end-users another.
- Industry-specific paths: Let visitors pick their industry and skip the noise.
- Highlight key features for each use case: Don't make marketing teams wade through engineering tools, and vice versa.
But be realistic—branching logic isn’t magic. If your product's core value is the same for everyone, don’t force complexity. But if you have different user types or use cases, it’s worth the setup.
Step 1: Decide what actually needs to branch
Before you even open Navattic, map out what should change in your demo. Don’t just add branches for the sake of it. Ask:
- What are the top 2–3 segments of people who’ll take this demo?
- Do they need to see totally different features, or just a slightly different intro?
- Where in the flow should they make a choice (if at all)?
Pro tip: Sketch your main flow and mark where a fork makes sense. Too many branches = maintenance nightmare. Start small.
What works: Branching for role (“I’m a manager” vs. “I’m a user”) or for product plan (“Starter” vs. “Pro”).
What doesn’t: Branching for every hypothetical (“Do you prefer blue or green buttons?”). Keep it tied to real needs.
Step 2: Build your base demo flow
Even if you plan to branch, always start with a single “happy path.” This will be the backbone of your demo.
- Create a new demo in Navattic.
- Record core steps: Focus on the must-see screens and actions.
- Write clear, concise captions: You’ll thank yourself later when you’re duplicating steps for branches.
Why bother? If you try to branch too soon, you’ll end up duplicating work or losing track of your steps. Get the core right, then clone as needed.
Step 3: Plan your branches (and keep them manageable)
Now, decide where your demo should split. In Navattic, “branching logic” means you can guide users down different paths based on their choices.
Typical branching points:
- Intro screen: “What best describes you?” or “What do you want to see?”
- Feature selection: Let users pick which features they care about.
- Use case selection: E.g., “Are you in sales or support?”
Tips for sanity:
- Limit the number of branches. Every branch is extra work to build, update, and QA.
- Reuse steps where possible. Navattic lets you send multiple branches back to a shared step—use this to avoid redundancy.
- Map it out visually. Even a napkin sketch helps.
Ignore: Branching just for fun or novelty. If a branch doesn’t help someone get to “aha!” faster, skip it.
Step 4: Add branching logic in Navattic
Here’s the nuts-and-bolts part. Navattic makes it easy enough, but you still need to be methodical.
How to set up branching:
- Insert a multiple-choice step: This is your fork in the road.
- E.g., “What’s your role?” with options like “Admin” and “User.”
- For each answer, link to the next step or group of steps:
- Click the option, then pick which step it should jump to.
- Build out each branch:
- Duplicate steps from your base flow.
- Tweak captions and actions as needed for that segment.
- (Optional) Merge branches later:
- If branches rejoin (e.g., everyone ends with the same signup page), link both back to a common step.
Pro tip: Use clear labels so you don’t lose track. “Step 5a – Admin features,” “Step 5b – User features,” etc.
What works: Letting people skip irrelevant steps. If you know someone’s not interested in Feature X, don’t show it.
What doesn’t: Overcomplicating with too many nested branches. You’ll confuse yourself and your users.
Step 5: Test every path—seriously
Branching logic multiplies the ways someone can move through your demo. If you don’t test all the branches, something will break.
- Run through each path as a user. Start from the intro, pick every option, and make sure you don’t hit dead ends.
- Check for skipped or repeated steps. Common mistake: a branch loops back to itself or skips a key screen.
- QA with a colleague. Fresh eyes catch weird flows.
Pro tip: Keep a checklist of all possible paths and tick them off as you test.
What works: Testing thoroughly before you share the link.
What doesn’t: Relying on “it worked for me.” Small flows might be fine, but branches multiply bugs.
Step 6: Measure and iterate quickly
Once your demo’s live, don’t just forget about it. Navattic gives you analytics on which branches people pick and where they drop off.
- See which paths get the most engagement. If nobody picks “Support” as their use case, maybe it’s not needed.
- Find out where people quit. Is there a branch that’s too long or confusing?
- Trim dead weight. Remove or simplify branches that don’t add value.
Pro tip: Less is more. The best demos are short, clear, and get people to “wow” fast.
Advanced tips (if you’re feeling confident)
- Personalize with variables: If you collect someone’s name or company, you can echo it in captions for a personal touch. Just don’t get creepy.
- Use tooltips and hotspots sparingly: Too many pop-ups and people will just click through without reading.
- A/B test different branches: If you’re not sure which fork is best, try both and see which converts better.
But, watch out: Advanced features are great—until you’re spending more time maintaining your demo than your actual product. Only go deep if you have the traffic or sales volume to justify it.
Keep it simple—and don’t overthink it
Branching logic in Navattic is powerful, but it’s easy to get lost in “what ifs.” Start small: one or two branches for your most important audience segments. Build, test, and watch how people actually use it. Iterate from there.
Remember: A tailored demo beats a generic one, but a confusing demo is worse than nothing. Keep it focused, keep it short, and let your product do the talking.