Project
Building HappyPath AI
My Role
Founder
Category
Startup
Year
2024-2025
Summary
Conceptualized and built a product guidance agent for B2B SaaS
Overview
HappyPath AI is an adaptive, AI-native product guidance agent designed to reduce time-to-value in complex B2B SaaS tools. The idea originated from years of expereince streamlining user experience for B2B SaaS. Users were still getting lost in products, despite beautiful UIs, onboarding tours, and help centers.
I started HappyPath as a solo founder during my sabbatical. I conducted early research, created design concepts, and prototyped the first version. I shipped early prototypes using a codegen assistant (Cline) that helped translate UI flows into a proof of concept.
Through the journey, Sahil Kumar joined me as co-founder. He led the engineering direction and helped us scale the product vision into a working beta. Together, we ran lean sprints, engaged with real users, and evolved the concept into a production-ready guidance platform.
This case study outlines how we validated the problem, built the product, and launched a live beta with growth-stage SaaS teams.
The Problem
B2B SaaS tools are powerful but notoriously difficult to navigate. Users face friction due to feature overload, divergent workflows, and generic onboarding.
Despite investments in walkthrough tools (e.g. Pendo), product tours, help centers, and redesigns, users continue to struggle with:
- Figuring out where to start
- Knowing how to reach value quickly
- Understanding what actions matter in their context
The Vision: HappyPath AI
HappyPath is an AI-native product guidance agent that adapts to what each user is trying to do, right inside the product. Rather than a one-size-fits-all tutorial, it delivers context-aware support, personalized workflows, and just-in-time nudges. Our goal was help users get unstuck without leaving the UI.
Demo Video
This short demo showcases HappyPath in action with Clay.com. It highlights the adaptive nature of the system and how it enhances user onboarding and productivity without relying on rigid walkthroughs or hardcoded flows.
What it does:
- Understands context: Pulls from documentation, past support tickets, usage logs.
- Gathers user intent: Converses with users to understand their goal.
- Watches the UI live: Uses a lightweight co-browsing layer to follow user actions.
- Generates in-context guidance: Offers dynamic hints or flows relevant to what the user is trying to do.
- Offers automation of workflows: Allows users to "auto-execute" workflows to save time and effort.
- Adapts to user feedback: Unlike static guides, the user can provide feedback and shape the guidance to be more relevant to them.
- Learns over time: Improves based on behavioral patterns and success rates
How it Works
At the core of HappyPath is a lightweight co-browsing layer that tracks real-time user behavior as well as the UI. This feeds into an AI engine that interprets user goals and matches them with the most relevant step. Over time, it learns and adapts, improving both accuracy and timing of interventions.
Why it matters:
Traditional onboarding tools treat every user the same, regardless of context, experience, or intent. HappyPath changes that. By adapting to the user’s goal in real time, it drastically reduces time to value, minimizes drop-off, and eliminates the burden of maintaining static tours. It turns onboarding into a personalized, self-improving experience.
- Faster activation: Users hit the “aha” moment quicker without digging through docs
- No handholding: PMs and engineers don’t need to maintain fragile product tours
- Dynamic adaptation: Helps bridge UI-doc drift and keeps guidance aligned
The Process
1. Problem Validation
I began by going deep into the real-world onboarding and adoption challenges facing SaaS teams. I conducted over 80 qualitative interviews with product managers, CS leaders, growth marketers, and designers across various industries and company sizes.
These conversations revealed a persistent pattern: despite investments in onboarding tools and redesigns, users were still getting stuck. They didn’t just need instructions, they needed intelligent guidance that aligned with their goals and context.
Some key findings:
- Teams were investing in onboarding tools and help docs, but users still struggled.
- Tools like Pendo and WalkMe were task-focused, not outcome-focused.
- Teams lacked visibility into whether users actually understood why they were doing something—not just how to do it.
- Maintenance was a major burden: scripted tours broke with every UI update.
The problem was very was clear: guidance needed to be contextual, adaptive, and tailored to user intent.
2. Defining the Ideal Customer Profile (ICP)
Synthesizing user interviews and market analysis to define a clear Ideal Customer Profile, I looked for companies where the pain was most acute and the need for a solution most urgent. This turned out to be mid to growth stage B2B SaaS businesses with:
- High level of feature complexity
- Self-serve onboarding or freemium funnels
- High support volume during onboarding
- PLG motions with product teams that valued data-driven decisions
The ICP definition helped us prioritize features, messaging, and integration strategies from the start.
| Industry | B2B SaaS - CRM, BI & Analytics, Monitoring Tools |
|---|---|
| High TTV (4-12 months) lowers adoption rate which impacts revenue | |
| High CAC has an impact on revenue. Companies are moving towards a PLG approach |
| Geography | North America has the highest market (35%-45%) for B2B SaaS companies. |
|---|---|
| *APAC is a growing at a faster rate than any other region. |
| Revenue | Scale Ups ($1-10 million ARR) |
|---|---|
| Don’t have extensive engineering resources to build it in house | |
| Need to apply a PLG approach to scale customers | |
| AI will become a significant part of the budget. |
| Employees | > 20-30 employees growing higher than 20% per year |
|---|---|
| < 1000 employees | |
| Product Mgt Team at this size is between 5 - 15 people. Have a decent budget for R&D. |
| Key Challenges | Company is scaling and product is not self serve - hence dependent on growing account service teams to acquire more users. |
|---|---|
| Users have a high TTV, can cause low adoption and churn | |
| Product has a lot of feature capability making it difficult for users to configure and use. | |
| Software is bloated - not easy to simplify workflows and add & maintain new features. |
| Value Prop | Makes the product self serve, reduces time to value - leads to quicker scaling and lower churn |
|---|---|
| Improves user experience by giving access to information quickly, making it more likely for users to renew | |
| Faster to integrate this than build and maintain it in the existing codebase. |
3. Conducting Market Research
To ensure we were solving a real and scalable problem, I conducted a detailed competitive analysis alongside a top-down market sizing exercise. I benchmarked existing digital adoption tools such as Pendo, WalkMe, Appcues, etc. and quickly noticed their limitations:
- Most relied on hardcoded steps
- Authoring flows required engineering or no-code builders
- There was no concept of adaptive flows based on real-time user behavior
- None pulled in dynamic context from support history or usage logs
This gave an opportunity space: an AI-native assistant that learned, adapted, and explained without the cost and rigidity of traditional onboarding tools.
Parallel to that, I researched the broader market landscape—sizing the Total Addressable Market (TAM) across B2B SaaS categories like CRM, BI/Analytics, and infrastructure tools.The opportunity became clear: no player had reimagined onboarding and product guidance from an AI-native lens. By combining behavioral intelligence, documentation parsing, and in-product context, we could deliver a differentiated solution that was faster to deploy and more effective than existing tools.
4. Conceptualizing and Building
Once there was a clear grasp of the problem and opportunity, we entered a phase of rapid experimentation. I treated this as a hypothesis-driven design sprint: developing mockups, lightweight prototypes, and demo narratives to test the concept and different interaction models. Our goal wasn’t to perfect the solution right away, but to learn quickly and validate what resonated.
Rapid Experiment Loop
We explored various formats: wizard-style onboarding flows, chat-based guidance, contextual tooltips, and intent-triggered next steps. These were tested with target users. Each round of feedback helped us refine not just the UI, but the core behaviors and triggers of the system.
I vibe-coded the v1 prototype, working with Cline as a codegen assistant to build a functional Chrome extension that could ingest documentation, observe UI activity, and offer step-by-step guidance with a second cursor. This allowed us to simulate the product experience and gather real-world reactions.
At each stage, we prioritized learning: What worked? What confused users? Where did they hesitate? These insights directly informed what we built next. The result was a lean, iterative process that moved us from concept to real usage quickly.
v0: AI Chatbot + Automated Workflows
The initial version of HappyPath started with a bold idea: what if users could simply describe what they wanted to do, and the product would do it for them?
At the time, agent-based automation was gaining traction, so we designed and tested mockups of a copilot-style assistant embedded within a SaaS product. The concept was simple, users would type a goal in natural language (e.g., “create a quarterly revenue dashboard” or “set up a new campaign”), and the system would automatically perform the necessary steps inside the UI. To build this, we explored integrations with open-source agents. We spoke with the team at LaVague, a community-led automation project, and experimented with using their browser automation agent to drive end-to-end workflows.
We tested this concept using sandbox environments inside Odoo and Tableau.
Demo
What we built:
- Mockups and scripted prototypes showing a user typing their goal and watching it auto-complete.
- Integration tests with LaVague to automate live UI actions.
- Chrome extension hooks to simulate embedded assistance.
What we observed:
- The agent could complete simple, well-structured tasks (e.g., navigating menus, setting filters).
- It struggled with multi-step, branching workflows that required decisions or user input.
- The experience felt magical when it worked, but:
- Latency was high (long wait times to complete a task).
- Cost per execution was non-trivial.
- Success rate dropped sharply as complexity increased.
Gathering Feedback
We ran concept testing sessions with design partners including Observe AI, Confluent, Atlassian, AWS, and several smaller SaaS companies.
Key Findings
- Teams were excited by the automation concept, but wanted more control and transparency.
- Users didn’t want a chatbot-style experience (“not another Intercom widget”). They preferred something that felt native and embedded in the product UI.
- Nudging users at moments of friction (e.g., repeated failed attempts, time spent on a screen) felt more valuable than proactive instruction.
This round of testing helped us reframe the product: not as a copilot that replaces the user, but as a smart assistant that supports them at the right moments.
v1: Intent based guidance
In response to earlier feedback, we evolved HappyPath into a hybrid model that offered both intelligent guidance and optional automation. Users could be guided step-by-step based on what they were doing, with the option to automate the entire sequence if desired.
This version introduced a second cursor to point at relevant UI elements in real time. The system interpreted the user’s goal, matched it with their current screen context, and nudged them through the process—almost like having a product expert walking them through the interface.
Building Proof of Concept
We had been hearing variations of the same sentiment from potential users: “If this actually works… it would be amazing.” So this version focused not just on improving UX, but also on testing the underlying technology’s reliability across different SaaS environments.
Instead of designing mockups, I went straight to prototyping using Cursor and Cline as codegen assistants. With gen AI codong tools improving, I could build testable a prototype even without a technical background. More importantly, I needed to evaluate technical feasibility - how reliably could HappyPath anchor to UI elements, read screen context, and respond to user flows? That level of testing wasn’t possible with static mocks.
What we built:
- A working Chrome extension that:
- Observed user actions and screen state
- Surfaced step-by-step guidance relevant to current context
- Offered optional “auto-complete” functionality for multi-step tasks
- Integrated basic memory: the system could track the user’s previous set of steps and suggest what should come next
- Prototyped and tested directly inside real tools like sales enablement tools, analytics platforms, and form-based SaaS apps
What we observed:
- The technology worked reasonably well. Early tests showed the system could reliably anchor to buttons, input fields, and dropdowns across many common web stacks
- The widget was able to offer useful guidance through the context provided by the knowledgebase articles
- Users could provide feedback and change the instruction provided by HappyPath, giving them more flexibility than static tours.
Gathering Feedback
Key Findings
- Strong demand for non-static guidance
- HappyPath was seen as more proactive and actionable compared to in-house AI chatbots.
- The widget took up too much real estate which was a problem specially for B2B SaaS
- One standout insight: “This is cool, but it still feels like I’m being handed steps. What if the system just knew what I needed next?”
That became a pivotal learning. Users didn’t want generic instructions. They wanted highly adaptive, real-time suggestions that responded to what they’d just done. This insight directly informed our next iteration, which focused on generating next steps dynamically based on prior user actions, making the experience feel truly personalized.
Current version: Product Guidance Agent
With strong validation from earlier iterations, we shifted our focus toward building a more robust, production-ready version of HappyPath, one that could be reliably tested inside real SaaS environments. At this stage, Sahil Kumar joined as co-founder and took on engineering leadership. We worked in one week sprints as he drove most of the development work, while I continued to shape the product experience and contributed code for features and UX improvements.
The goal was to evolve HappyPath from a promising prototype into a flexible, testable product that could adapt to different UI environments, minimize setup friction, and support multiple modes of guidance.
What we built
UX Changes
- Redesigned the interface from a static side panel to a movable widget anchored to the bottom of the screen.
- Introduced two user modes:
- Conversation Mode: A chat-like interface where users can express intent, clarify instructions, give feedback, or modify steps.
- Workflow Mode: The widget compresses and shifts focus to a cursor-driven overlay that actively guides the user step-by-step through the UI.
Technical Changes
- Built two deployment modes:
- Chrome extension for demo and internal testing.
- Embeddable JavaScript snippet for integrating HappyPath directly into partner environments without installation overhead.
- Had to find a workaround to avoid using browser automation stacks like Playwright or Puppeteer, which required installation from the user.
- Implemented a screenshot-based feedback loop, capturing UI state and user actions at every step. This allowed us to understand where users were in the workflow and determine the best next step dynamically.
Prototype
Setup
Managing Workflows
Analytics Dashboard
We also began preparing for a structured beta program, reaching out to design partners and setting up test workflows inside their products. This allowed us to observe real usage patterns and refine both the experience and the technical performance in the wild.
Running a Beta Program
With a stable, testable version of HappyPath ready, we launched a private beta to evaluate the product in real SaaS environments. We focused our outreach on product and growth teams with complex onboarding challenges, limited engineering bandwidth, and a strong interest in PLG (product-led growth).
We framed the pitch around a simple question:"What if your product could explain itself?"
How we approached it
- Created a landing page with a concise narrative and demo video, and a Beta sign up form.
- Used LinkedIn outreach, warm intros, and 1:1 product walkthroughs to recruit beta users.
- Recruited 8 teams across SaaS domains like DevOps, analytics, compliance, and developer tools.
- Helped them onboard using our lightweight JavaScript embed or Chrome extension.
- Ran structured calls where we observed live usage, guided setup, and gathered feedback in real time
What we tracked and learned
- User behavior: We closely monitored how users moved through workflows, where they got stuck, and whether guidance appeared at the right time.
- Hint accuracy: We measured the relevance and usefulness of each suggestion, using both qualitative comments and behavioral indicators (completion rate, dismissals, hesitations).
- Edge cases: We captured breakpoints where UI drift, unexpected layouts, or embedded widgets interfered with guidance accuracy.
- Feedback channels: We established a tight feedback loop. Users could give feedback in Discord, and we used that to inform weekly design + engineering sprints
