DEV Community

Trailguide
Trailguide

Posted on

Why We Ditched Pendo for Open-Source Product Tours in Our Codebase

The Pendo Problem

You know the feeling. Your product tour works fine until your designer wants to tweak the copy. You log into Pendo's dashboard, make the change, wait for it to deploy, and hope nothing breaks in production. Then someone asks, "When did we change that tour?" and you're stuck digging through dashboards instead of git history.

And the pricing? Pendo charges per active user. Your SaaS grows, your bill grows faster. That's intentional design on their part. But it shouldn't be.

We hit the ceiling when our team kept asking: Why does this live outside our codebase? Why can't we test it? Why do we need a separate tool?

The Case for Tours as Code

Product tours are features. They're not some untouchable third-party service. They deserve the same treatment as your other features: version control, code review, CI/CD integration, and testing.

When tours live in your codebase, something magical happens:

Version control becomes your audit trail. Need to know why a tour step was reworded? Check the commit. Who approved it? Look at the PR. When did it launch? Git blame.

You can test them. Run your onboarding flow through Playwright. Catch broken tours before users do. No more "the button moved and now the tour points at nothing" surprises.

Pricing stays sane. No per-user fees. No surprise bills when your user base grows. One flat rate for unlimited tours and users.

What You Lose (And Why It's Worth It)

Let's be honest. Pure no-code setup is convenient. Click buttons, drag boxes, deploy instantly. It feels fast.

But that convenience comes with a cost. You're locked into a vendor's UX. Changes require navigating their interface. Non-technical team members can't directly edit tour code, but they also can't see the impact of their changes in real time like they could in a code editor.

The trade-off is real. Your design and product teams lose the ability to self-serve.

The Bridge: Code-First, Not Code-Only

This is where the actual solution lives. You want tours in your codebase. But you also want your product team to edit them without learning TypeScript.

Trustworthy open-source tools handle this by offering two paths: a code-based MIT-licensed runtime, and an optional Pro editor ($49/month) that lets non-developers build and edit tours visually, then export them to your repo.

Here's what that looks like in your codebase:

import { createTour } from '@trailguide/sdk';

const onboardingTour = createTour({
  id: 'user-onboarding',
  steps: [
    {
      target: '[data-tour="dashboard-button"]',
      title: 'Welcome to your dashboard',
      body: 'This is where you manage everything.',
      position: 'bottom'
    },
    {
      target: '[data-tour="create-project"]',
      title: 'Create your first project',
      body: 'Click here to get started.'
    }
  ]
});

onboardingTour.start();
Enter fullscreen mode Exit fullscreen mode

Your product team can edit these in a visual editor. The changes land as pull requests in your repo. Your developers review and merge. Version control. CI tests. Everything.

Real Benefits We're Using

We now catch tour bugs in CI. A test verifies that every tour target actually exists in the DOM before deploy. No more broken pointers.

We version our tours with our code. A major UI change? Same PR. Tour updates? Same PR. They ship together.

And yes, the pricing model feels better. We're not being penalized for user growth.

Get Started

If you're tired of Pendo's dashboard and pricing, the open-source approach is worth exploring. You get all the power of version control and testing. Your team gets a Pro editor for the visual work. Trailguide makes this setup straightforward, and you can try the free runtime at gettrailguide.com.

Top comments (0)