Pendo step map & guide branching

Why branching, & why now

Pendo's Salesforce data made the case clearly: the absence of native guide branching was cited as a deal-breaker, resulting in $1.3M in lost opportunities and a contributing challenge in $4.4M more.

A customer ideas test with over 150 respondents showed a consistent pattern of enterprise accounts at companies like ADP, Amazon, Thomson Reuters, and McGraw-Hill all described the same workarounds: duplicated guides, fragile custom JavaScript, and skip-step hacks to cobble together branching behavior that should have been native.

The competitive landscape

Former WalkMe customers were especially frustrated. Several customers cited branching guides as a feature they lost when switching to Pendo, creating a direct competitive gap.

The core job to be done was clear: guide authors needed to create experiences that respond to who the user is and what's true about their context without writing code.

The process

Running discovery across multiple customer segments

I ran a series of discovery calls to pressure-test the problem and understand what a good solution would actually need to do. The most consistent finding was that customers weren't just asking for branching logic.

They needed visibility into their guide logic. As guides grew more complex with things like soft branching logic and conditional steps, the linear film strip made it nearly impossible to understand what a guide actually did, let alone edit it confidently.

The main job to be done

It was good to get some solid understanding of the job that needed to be done. The branching logic was half the problem. The visualization of that logic was the other half.

Working with engineering

I made a deliberate choice to bring engineers into these discovery sessions rather than relay findings secondhand. This helped significantly cut down the feedback cycle while building a strong sense of team ownership of this project. The team could hear constraints and edge cases directly, ideate on technical feasibility in the room, and move faster without a game of telephone between design, product, and engineering.

Building 2 features together

The solution took shape as two interconnected features:

The step map

A full-screen node-based visualization of a guide's complete flow. Every step and button action is represented as a node, with arrows showing how the guide moves between them. Authors can click any node to view or edit that step without leaving the map.

Guide branching (element exists on page)

A conditional split that can be inserted anywhere in a guide flow. Authors select a tagged element, and the guide branches into an if/else path based on whether that element is present on the page for a specific viewer. No code required.

These weren't two separate projects. Without branching, a step map has limited value. Without a step map, branching creates flows that are impossible to reason about. The two had to ship together to actually solve the problem.

Designing similar features

Our most significant challenge was an internal one. Another team at Pendo was building a similar step map visualization for Orchestrate Journeys, and leadership pushed for the two to share a visual language. The pressure to unify made sense: one consistent design pattern, less user confusion.

Justifying the difference

The two features look similar but function fundamentally differently. Journeys are always forward-moving, which allows them to follow a strict tree structure. Guides are not. A guide can loop back to a previous step, branch and revisit steps, or take a user in directions that a basic tree diagram simply can't represent accurately.

Building the Guides step map to look like the Journeys map would have meant shipping a visualization that misrepresented how guides actually work. This had a big learning issue because it meant teaching users a mental model that would break the moment they built anything that let users go back to a previous step, let alone one that jumps to a step further along in a guide.

Validating before launch

Before the GA launch, I ran usability testing sessions with guide authors to stress-test the designs. Key findings shaped the final experience:

The step map in the wild

We initially shipped to internal Pendozers first. As of writing this, the Step Map has seen 2,483 "view-step-map" events over a two-week window and 1,624 monthly users, half a year after its GA launch — a strong signal of sustained adoption.

Average time to first use ranged from 1.8 to 3.2 days amongst frequent guide builders, indicating that users discovered and used the feature quickly after first encountering it.

Using Pendo for analytics

The dashboard analytics told us a lot. The most common tracked feature click after opening the Step Map was interacting with a Guide step node, followed by using the VDS action bar entry point. This told me that users were using the map to navigate directly to the steps they wanted to edit and reopening the map later. This was one of the workflows the research pointed to and we wanted to make sure we designed for.

Customer feedback

Customer feedback after launch confirmed both the value and the direction for what comes next:

The feedback shows something important. Customers started using the Step Map as a planning and collaboration tool, not just for visualization. This suggests the feature fits more naturally into their workflow than we first thought.

Going forward

This project is one of the most complex things I've worked on. Sure, the interactions were technically difficult, but the problem also had so many layers: customer jobs to be done, internal organizational dynamics, competitive pressure, and the challenge of designing a new mental model inside an existing product.

The most important thing I learned is that getting to the right solution often means over-indexing on the work that doesn't show up in the final designs. The discovery calls that reframed the problem, the engineering sessions that compressed the feedback cycle, the internal advocacy that kept the Step Map accurate, etc. All of that shaped the outcome as much as the wireframes.

Branching is live. The Step Map is live. We managed to move the needle on the problem we started with: guide creators can now see and control complex flows they never could before.